Release v0.25.4

Default and non-default behaviour was mixed in the same paragraph,
leading to confusion about when an ICC profile might be expected.

.cirrus.yml

@@ -1,12 +1,13 @@
 freebsd_instance:
-  image_family: freebsd-12-0
+  image_family: freebsd-13-0-snap
 
 task:
+  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
   test_script:

.github/CONTRIBUTING.md

@@ -44,8 +44,7 @@ Any change that modifies the existing public API should be added to the relevant
 
 | Release | WIP branch |
 | ------: | :--------- |
-| v0.24.0 | wit        |
-| v0.25.0 | yield      |
+| v0.26.0 | zoom       |
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 

.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,20 +1,20 @@
 ---
 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?
 
+Are you using the latest version? Is the version currently in use as reported by `npm ls sharp` the same as the latest version as reported by `npm view sharp dist-tags.latest`?
+
 If you are installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
 
 If you are using 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?

.travis.yml

@@ -1,75 +1,178 @@
-matrix:
+jobs:
   include:
-    - name: "Linux (glibc 2.17+) - Node.js 10"
-      os: linux
-      dist: xenial
-      language: node_js
-      node_js: "10"
-    - name: "Linux (glibc 2.17+) - Node.js 12"
-      os: linux
-      dist: xenial
-      language: node_js
-      node_js: "12"
-    - name: "Linux (glibc 2.17+) - Node.js 13"
-      os: linux
-      dist: xenial
-      language: node_js
-      node_js: "13"
-      after_success:
-        - npm install coveralls
-        - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
-    - name: "Linux (musl 1.1.20+) - Node.js 10"
+    - name: "Linux x64 (CentOS 7, glibc 2.17) - Node.js 10"
       os: linux
       dist: bionic
-      language: minimal
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp centos:7
+        - sudo docker exec sharp bash -c "curl -sL https://rpm.nodesource.com/setup_10.x | bash -"
+        - sudo docker exec sharp yum install -y gcc-c++ make git nodejs
+      install: sudo docker exec sharp bash -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp bash -c "npm test"
+
+    - name: "Linux x64 (CentOS 7, glibc 2.17) - Node.js 12"
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp centos:7
+        - sudo docker exec sharp bash -c "curl -sL https://rpm.nodesource.com/setup_12.x | bash -"
+        - sudo docker exec sharp yum install -y gcc-c++ make git nodejs
+      install: sudo docker exec sharp bash -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp bash -c "npm test"
+
+    - name: "Linux x64 (CentOS 7, glibc 2.17) - Node.js 13"
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp centos:7
+        - sudo docker exec sharp bash -c "curl -sL https://rpm.nodesource.com/setup_13.x | bash -"
+        - sudo docker exec sharp yum install -y gcc-c++ make git nodejs
+      install: sudo docker exec sharp bash -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp bash -c "npm test"
+
+    - name: "Linux x64 (CentOS 7, glibc 2.17) - Node.js 14"
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp centos:7
+        - sudo docker exec sharp bash -c "curl -sL https://rpm.nodesource.com/setup_14.x | bash -"
+        - sudo docker exec sharp yum install -y gcc-c++ make git nodejs
+      install: sudo docker exec sharp bash -c "npm install --unsafe-perm"
+      script: sudo docker exec sharp bash -c "npm test"
+
+    - name: "Linux x64 (Alpine 3.9, musl 1.1.20) - Node.js 10"
+      os: linux
+      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.17.0-alpine3.9 # https://github.com/nodejs/docker-node/issues/1158
         - sudo docker exec sharp apk add build-base git python2 --update-cache
       install: sudo docker exec sharp sh -c "npm install --unsafe-perm"
       script: sudo docker exec sharp sh -c "npm test"
-    - name: "Linux (musl 1.1.20+) - Node.js 12"
+
+    - name: "Linux x64 (Alpine 3.11, musl 1.1.20) - Node.js 12"
       os: linux
       dist: bionic
-      language: minimal
+      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"
       script: sudo docker exec sharp sh -c "npm test"
-    - name: "Linux (musl 1.1.20+) - Node.js 13"
+
+    - name: "Linux x64 (Alpine 3.11, musl 1.1.20) - Node.js 13"
       os: linux
       dist: bionic
-      language: minimal
+      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"
       script: sudo docker exec sharp sh -c "npm test"
-    - name: "Linux ARM64v8 (glibc 2.29+) - Node.js 10"
+
+    - name: "Linux x64 (Alpine 3.11, musl 1.1.20) - Node.js 14"
+      os: linux
+      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:14.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"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 10"
       arch: arm64
       os: linux
       dist: bionic
-      language: minimal
+      language: shell
       before_install:
-        - sudo docker run -dit --name sharp --env CI --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
-        - sudo docker exec sharp apt-get update
-        - sudo docker exec sharp apt-get install -y build-essential git python2 nodejs npm
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --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 python2 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 buster 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 --unsafe-perm"
       script: sudo docker exec sharp sh -c "npm test"
-    - name: "macOS (10.13+) - Node.js 10"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 12"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --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 python2 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 buster 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 --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 13"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --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 python2 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_13.x buster 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 --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "Linux ARM64v8 (Debian 11, glibc 2.29) - Node.js 14"
+      arch: arm64
+      os: linux
+      dist: bionic
+      language: shell
+      before_install:
+        - sudo docker run -dit --name sharp --env CI --env PREBUILD_TOKEN --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 python2 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 buster 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 --unsafe-perm"
+      script: sudo docker exec sharp sh -c "npm test"
+
+    - name: "macOS (10.13) - Node.js 10"
       os: osx
       osx_image: xcode10.1
       language: node_js
       node_js: "10"
-    - name: "macOS (10.13+) - Node.js 12"
+
+    - name: "macOS (10.13) - Node.js 12"
       os: osx
       osx_image: xcode10.1
       language: node_js
       node_js: "12"
-    - name: "macOS (10.13+) - Node.js 13"
+
+    - name: "macOS (10.13) - Node.js 13"
       os: osx
       osx_image: xcode10.1
       language: node_js
       node_js: "13"
+
+    - name: "macOS (10.13) - Node.js 14"
+      os: osx
+      osx_image: xcode10.1
+      language: node_js
+      node_js: "14"
+
+    - name: "Unit test coverage report"
+      os: linux
+      dist: bionic
+      language: node_js
+      node_js: "13"
+      before_install: unset PREBUILD_TOKEN
+      after_success:
+        - npm install coveralls
+        - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js
+
 cache:
   npm: false

README.md

@@ -1,10 +1,6 @@
 # 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
@@ -20,12 +16,15 @@ 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 macOS, Windows and Linux systems running
-Node versions 10, 12 and 13
+Most modern macOS, Windows and Linux systems running Node.js v10+
 do not require any additional install or runtime dependencies.
 
 ## Examples
 
+```sh
+npm install sharp
+```
+
 ```javascript
 const sharp = require('sharp');
 ```
@@ -86,14 +85,15 @@ readableStream
 ```
 
 [![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![N-API v3](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
 ### Documentation
 
 Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
-[installation instructions](https://sharp.pixelplumbing.com/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).
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
 
 ### Contributing
 

appveyor.yml

@@ -1,15 +1,26 @@
 os: Visual Studio 2017
 version: "{build}"
 build: off
-platform: x64
 environment:
   matrix:
   - nodejs_version: "10"
+    platform: x86
+  - nodejs_version: "10"
+    platform: x64
   - nodejs_version: "12"
+    platform: x86
+  - nodejs_version: "12"
+    platform: x64
   - nodejs_version: "13"
+    platform: x86
+  - nodejs_version: "13"
+    platform: x64
+  - nodejs_version: "14"
+    platform: x86
+  - nodejs_version: "14"
+    platform: x64
 install:
-  - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version) x64
-  - npm install -g npm@6
+  - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version) $env:platform
   - npm install
 test_script:
   - npm test

binding.gyp

@@ -29,7 +29,22 @@
           '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': [
@@ -44,7 +59,11 @@
     ]
   }, {
     'target_name': 'sharp',
+    'defines': [
+      'NAPI_VERSION=3'
+    ],
     'dependencies': [
+      '<!(node -p "require(\'node-addon-api\').gyp")',
       'libvips-cpp'
     ],
     'variables': {
@@ -65,11 +84,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")',
     ],
     'conditions': [
       ['use_global_libvips == "true"', {
@@ -114,7 +133,7 @@
               '../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\''
+              '-Wl,-s -rpath \'@loader_path/../../vendor/lib\''
             ]
           }],
           ['OS == "linux"', {
@@ -157,7 +176,7 @@
               '../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\''
+              '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$${ORIGIN}/../../vendor/lib\''
             ]
           }]
         ]
@@ -189,10 +208,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

@@ -1,6 +1,6 @@
 # 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">
+<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
@@ -16,12 +16,9 @@ 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 macOS, Windows and Linux systems running
-Node versions 10, 12 and 13
+Most modern macOS, Windows and Linux systems running Node.js v10+
 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.
@@ -67,73 +64,6 @@ as [pngcrush](https://pmt.sourceforge.io/pngcrush/).
 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)
-* [Brychan Bennett-Odlum](https://github.com/BrychanOdlum)
-
-Thank you!
-
 ### Licensing
 
 Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.

docs/api-channel.md

@@ -42,16 +42,17 @@ 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][2])** 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
    });
 ```
 
@@ -74,7 +75,7 @@ For raw pixel input, the `options` object should contain a `raw` attribute, whic
 
 ### Parameters
 
--   `images` **([Array][4]<([String][2] \| [Buffer][5])> | [String][2] \| [Buffer][5])** one or more images (file paths, Buffers).
+-   `images` **([Array][4]<([string][2] \| [Buffer][5])> | [string][2] \| [Buffer][5])** one or more images (file paths, Buffers).
 -   `options` **[Object][6]** image options, see `sharp()` constructor.
 
 
@@ -88,7 +89,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][2]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
 
 ### Examples
 

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,7 +46,7 @@ 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]
 
 
 -   Throws **[Error][4]** Invalid parameters
@@ -59,7 +59,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]?** 

docs/api-constructor.md

@@ -2,32 +2,42 @@
 
 ## 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.
+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
+-   `input` **([Buffer][2] \| [string][3])?** 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.
+-   `options` **[Object][4]?** if present, is an Object with optional attributes.
+    -   `options.failOnError` **[boolean][5]** by default halt processing and raise an error when loading invalid images.
          Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid. (optional, default `true`)
-    -   `options.limitInputPixels` **([Number][5] \| [Boolean][4])** Do not process input images where the number of pixels
+    -   `options.limitInputPixels` **([number][6] \| [boolean][5])** 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][4]** Set this to `true` to use sequential rather than random access where possible.
+    -   `options.sequentialRead` **[boolean][5]** 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][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.density` **[number][6]** number representing the DPI for vector images. (optional, default `72`)
+    -   `options.pages` **[number][6]** number of pages to extract for multi-page input (GIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
+    -   `options.page` **[number][6]** page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based. (optional, default `0`)
+    -   `options.level` **[number][6]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    -   `options.raw` **[Object][4]?** describes raw pixel input image data. See `raw()` for pixel ordering.
+        -   `options.raw.width` **[number][6]?** 
+        -   `options.raw.height` **[number][6]?** 
+        -   `options.raw.channels` **[number][6]?** 1-4
+    -   `options.create` **[Object][4]?** describes a new image to be created.
+        -   `options.create.width` **[number][6]?** 
+        -   `options.create.height` **[number][6]?** 
+        -   `options.create.channels` **[number][6]?** 3-4
+        -   `options.create.background` **([string][3] \| [Object][4])?** parsed by the [color][7] module to extract values for red, green, blue and alpha.
 
 ### Examples
 
@@ -68,9 +78,9 @@ sharp({
 .then( ... );
 ```
 
--   Throws **[Error][7]** Invalid parameters
+-   Throws **[Error][8]** Invalid parameters
 
-Returns **[Sharp][8]** 
+Returns **[Sharp][9]** 
 
 ## clone
 
@@ -89,20 +99,71 @@ readableStream.pipe(pipeline);
 // secondWritableStream receives auto-rotated, extracted region of readableStream
 ```
 
-Returns **[Sharp][8]** 
+```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
+});
 
-[1]: https://nodejs.org/api/buffer.html
+const promises = [];
 
-[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+promises.push(
+  sharpStream
+    .clone()
+    .jpeg({ quality: 100 })
+    .toFile("originalFile.jpg")
+);
 
-[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .jpeg({ quality: 80 })
+    .toFile("optimized-500.jpg")
+);
 
-[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .webp({ quality: 80 })
+    .toFile("optimized-500.webp")
+);
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+// https://github.com/sindresorhus/got#gotstreamurl-options
+got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
 
-[6]: https://www.npmjs.org/package/color
+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) {}
+  });
+```
 
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+Returns **[Sharp][9]** 
 
-[8]: #sharp
+[1]: http://nodejs.org/api/stream.html#stream_class_stream_duplex
+
+[2]: https://nodejs.org/api/buffer.html
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[7]: https://www.npmjs.org/package/color
+
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[9]: #sharp

docs/api-input.md

@@ -20,6 +20,7 @@ A `Promise` is returned when `callback` is not provided.
 -   `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
 -   `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
 -   `pagePrimary`: Number of the primary page in a HEIF image
+-   `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
 -   `hasProfile`: Boolean indicating the presence of an embedded ICC profile
 -   `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
 -   `orientation`: Number value of the EXIF Orientation header, if present
@@ -68,8 +69,9 @@ 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)
 
 ### Parameters
 
@@ -86,11 +88,15 @@ image
   });
 ```
 
+```javascript
+const { entropy, sharpness } = await sharp(input).stats();
+```
+
 Returns **[Promise][5]<[Object][6]>** 
 
-[1]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636
+[1]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation
 
-[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
 

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
 
@@ -74,9 +74,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 +90,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 +105,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
@@ -119,7 +119,7 @@ Merge alpha transparency channel, if any, with a background.
 ### Parameters
 
 -   `options` **[Object][2]?** 
-    -   `options.background` **([String][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
+    -   `options.background` **([string][3] \| [Object][2])** background colour, parsed by the [color][4] module, defaults to black. (optional, default `{r:0,g:0,b:0}`)
 
 Returns **Sharp** 
 
@@ -135,8 +135,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 +180,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
 
@@ -212,7 +212,7 @@ Any pixel value greather than or equal to the threshold value will be set to 255
 
 ### 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 +231,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 +250,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 +264,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
 
@@ -298,9 +297,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
 

docs/api-output.md

@@ -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).
@@ -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
@@ -91,13 +91,15 @@ 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.
 
+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.
 
 ### Examples
 
@@ -118,7 +120,7 @@ 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
@@ -138,21 +140,23 @@ Returns **Sharp**
 
 Use these JPEG options for output image.
 
+Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
+
 ### Parameters
 
 -   `options` **[Object][6]?** output options
-    -   `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`)
+    -   `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]** for quality < 90, set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' (use chroma subsampling); for quality >= 90 chroma is never subsampled (optional, default `'4:2:0'`)
+    -   `options.optimiseCoding` **[boolean][7]** optimise Huffman coding tables (optional, default `true`)
+    -   `options.optimizeCoding` **[boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
+    -   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg (optional, default `false`)
+    -   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg (optional, default `0`)
+    -   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg (optional, default `0`)
+    -   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -177,18 +181,20 @@ Use these PNG options for output image.
 PNG output is always full colour at 8 or 16 bits per pixel.
 Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
 
+Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+
 ### Parameters
 
 -   `options` **[Object][6]?** 
-    -   `options.progressive` **[Boolean][7]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.compressionLevel` **[Number][9]** zlib compression level, 0-9 (optional, default `9`)
-    -   `options.adaptiveFiltering` **[Boolean][7]** use adaptive row filtering (optional, default `false`)
-    -   `options.palette` **[Boolean][7]** quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant (optional, default `false`)
-    -   `options.quality` **[Number][9]** use the lowest number of colours needed to achieve given quality, 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`)
+    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    -   `options.compressionLevel` **[number][9]** zlib compression level, 0-9 (optional, default `9`)
+    -   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
+    -   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant (optional, default `false`)
+    -   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `100`)
+    -   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
+    -   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `256`)
+    -   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant (optional, default `1.0`)
+    -   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -210,13 +216,13 @@ 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`)
+    -   `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
 
@@ -238,17 +244,17 @@ 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`)
+    -   `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
 
@@ -281,9 +287,9 @@ Most versions of libheif support only the patent-encumbered HEVC compression for
 ### 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`)
+    -   `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
@@ -296,7 +302,9 @@ Returns **Sharp**
 
 ## raw
 
-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.
 
 ### Examples
 
@@ -307,6 +315,16 @@ const { data, info } = await sharp('input.jpg')
   .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
@@ -320,14 +338,14 @@ 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][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`, `iiif`, `zoomify` or `google`. (optional, default `'dz'`)
 
 ### Examples
 

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.
@@ -134,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]?** 
+    -   `extend.left` **[number][8]?** 
+    -   `extend.bottom` **[number][8]?** 
+    -   `extend.right` **[number][8]?** 
     -   `extend.background` **([String][10] \| [Object][9])** background colour, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
 
 ### Examples
@@ -164,7 +166,7 @@ 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.
@@ -173,10 +175,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
 
@@ -211,7 +213,7 @@ The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` pro
 
 ### 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

@@ -31,10 +31,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][2])** Object with the following attributes, or boolean where true uses default cache settings and false removes all caching (optional, default `true`)
+    -   `options.memory` **[number][3]** is the maximum memory in MB to use for this cache (optional, default `50`)
+    -   `options.files` **[number][3]** is the maximum number of files to hold open (optional, default `20`)
+    -   `options.items` **[number][3]** is the maximum number of operations to cache (optional, default `100`)
 
 ### Examples
 
@@ -64,7 +64,7 @@ This method always returns the current concurrency.
 
 ### Parameters
 
--   `concurrency` **[Number][3]?** 
+-   `concurrency` **[number][3]?** 
 
 ### Examples
 
@@ -74,7 +74,7 @@ sharp.concurrency(2); // 2
 sharp.concurrency(0); // 4
 ```
 
-Returns **[Number][3]** concurrency
+Returns **[number][3]** concurrency
 
 ## queue
 
@@ -116,7 +116,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][2]**  (optional, default `true`)
 
 ### Examples
 
@@ -130,7 +130,7 @@ const simd = sharp.simd(false);
 // prevent libvips from using liborc at runtime
 ```
 
-Returns **[Boolean][2]** 
+Returns **[boolean][2]** 
 
 [1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
 

docs/changelog.md

@@ -1,9 +1,94 @@
 # Changelog
 
+## 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.

docs/firebase.json

@@ -4,9 +4,10 @@
     "public": ".",
     "ignore": [
       ".*",
-      "*.json",
+      "firebase.json",
       "*.md",
-      "image/**"
+      "image/**",
+      "search-index/**"
     ],
     "headers": [
       {
@@ -25,6 +26,11 @@
         "destination": "/install",
         "type": 301
       },
+      {
+        "source": "/page/install",
+        "destination": "/install",
+        "type": 301
+      },
       {
         "source": "**/api-constructor/**",
         "destination": "/api-constructor",
@@ -70,16 +76,31 @@
         "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": "/",

docs/humans.txt

@@ -0,0 +1,190 @@
+/* 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

docs/index.html

@@ -1,9 +1,10 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta name="description" content="Resize large images in common formats to smaller, web-friendly JPEG, PNG and WebP images of varying dimensions">
   <link rel="icon" type="image/png" href="https://pixel.plumbing/px/32x32/sharp-logo.svg">
   <link rel="apple-touch-icon-precomposed" sizes="152x152" href="https://pixel.plumbing/px/152x152/sharp-logo.svg">
   <link rel="apple-touch-icon-precomposed" sizes="144x144" href="https://pixel.plumbing/px/144x144/sharp-logo.svg">
@@ -11,8 +12,35 @@
   <link rel="apple-touch-icon-precomposed" sizes="114x114" href="https://pixel.plumbing/px/114x114/sharp-logo.svg">
   <link rel="apple-touch-icon-precomposed" sizes="72x72" href="https://pixel.plumbing/px/72x72/sharp-logo.svg">
   <link rel="apple-touch-icon-precomposed" href="https://pixel.plumbing/px/57x57/sharp-logo.svg">
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docute@4/dist/docute.min.css">
+  <style>/* https://cdn.jsdelivr.net/npm/docute@4/dist/docute.min.css */ body{margin:0;color:var(--text-color);background:var(--page-background);text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;font:16px/1.7 -apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif}*{box-sizing:border-box}a{color:var(--link-color);text-decoration:none}.page-content>:first-child{margin-top:0}.page-content.has-page-title>h2:first-child{margin-top:7rem}.page-content h2,.page-content h3{font-weight:300;line-height:1.2}.page-content h2{font-size:2rem;border-bottom:1px solid var(--border-color);margin-top:7rem;padding-bottom:5px}.page-content h3{font-size:1.7rem;margin:40px 0 30px}.page-content code{font-family:var(--code-font);font-size:90%;background:var(--inline-code-background);border-radius:4px;padding:3px 5px;color:var(--inline-code-color)}.page-content>ul{padding-left:20px;margin:1rem 0}.page-content img{max-width:100%}@-webkit-keyframes blink-data-v-4f620c69{to{opacity:.2}}@keyframes blink-data-v-4f620c69{0%{opacity:.2}20%{opacity:1}to{opacity:.2}}</style>
+  <link rel="author" href="/humans.txt" type="text/plain">
+  <link rel="preload" href="https://cdn.jsdelivr.net/gh/lovell/sharp@v0.25.4/docs/README.md" as="fetch" type="text/markdown" crossorigin>
+  <link rel="preload" href="https://cdn.jsdelivr.net/gh/lovell/sharp@master/docs/image/sharp-logo.svg" as="image" type="image/svg+xml" crossorigin>
+  <link rel="dns-prefetch" href="https://pixel.plumbing">
+  <link rel="dns-prefetch" href="https://www.google-analytics.com">
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "SoftwareSourceCode",
+    "name": "sharp",
+    "description": "High performance Node.js image processing",
+    "url": "https://sharp.pixelplumbing.com",
+    "codeRepository": "https://github.com/lovell/sharp",
+    "programmingLanguage": ["JavaScript", "C++"],
+    "runtimePlatform": "Node.js",
+    "copyrightHolder": {
+      "@context": "https://schema.org",
+      "@type": "Person",
+      "name": "Lovell Fuller"
+    },
+    "copyrightYear": [2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020],
+    "license": "https://www.apache.org/licenses/LICENSE-2.0"
+  }
+  </script>
   <style>
+  :root {
+    --link-color: #077;
+  }
   @media (max-width: 576px) {
     .shorten-strapline {
       display: none;
@@ -21,6 +49,16 @@
   img[alt='sharp logo'] {
     margin: 0 0 16px 16px;
   }
+  .page-content > h2,
+  .page-content.has-page-title > h2:first-child {
+    margin-top: 3rem;
+  }
+  .page-content h3 {
+    font-size: 1.4rem;
+  }
+  ul ul {
+    padding-left: 20px;
+  }
   </style>
   <title>sharp - High performance Node.js image processing</title>
 </head>
@@ -28,13 +66,13 @@
 <body>
   <div id="docute"></div>
   <script src="https://cdn.jsdelivr.net/npm/docute@4/dist/docute.min.js"></script>
-  <script src="https://cdn.jsdelivr.net/npm/docute-google-analytics@1/dist/index.min.js"></script>
   <script>
-    var docuteApiTitlePlugin = {
+    /* https://cdn.jsdelivr.net/npm/docute-google-analytics@1/dist/index.min.js */ !function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e=e||self).docuteGoogleAnalytics=n()}(this,function(){"use strict";function e(e){var n;window.ga||((n=document.createElement("script")).async=!0,n.src="https://www.google-analytics.com/analytics.js",document.body.appendChild(n),window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=Number(new Date),ga("create",e,"auto"))}function n(n,t){e(t),ga("set","page",n),ga("send","pageview")}return function(e){return{name:"@google-analytics",extend:function(t){!function(e,t){"function"==typeof e?e(function(e){n(e,t)}):e.afterEach(function(e){n(e.fullPath,t)})}(t.router,e)}}}});
+    const docuteApiTitlePlugin = {
       name: 'apiTitle',
       extend(api) {
         api.processMarkdown(function (md) {
-          var title = api.store.getters.sidebarLinks
+          const title = api.store.getters.sidebarLinks
             .filter(function (sidebarLink) {
               return sidebarLink.link === api.router.history.current.path
             })
@@ -47,6 +85,37 @@
         });
       }
     };
+    const docuteApiSearchPlugin = {
+      name: 'apiSearch',
+      extend(api) {
+        api.enableSearch({
+          handler: function (keyword) {
+            if (keyword.trim().length > 2) {
+              return fetch('/search-index.json')
+                .then(function (res) {
+                  return res.json();
+                })
+                .then(function (entries) {
+                  const results = [];
+                  entries.forEach(function (entry) {
+                    if (entry.k.includes(keyword)) {
+                      results.push({
+                        title: entry.t,
+                        link: entry.l,
+                        description: entry.d,
+                        label: entry.l.startsWith("/api") ? "API" : "Install"
+                      });
+                    }
+                  })
+                  return results.slice(0, 3);
+                })
+            } else {
+              return [];
+            }
+          }
+        });
+      }
+    };
     new Docute({
       router: { mode: 'history' },
       logo: '<div style="display:flex;align-items:center">'
@@ -60,9 +129,10 @@
       footer: '<a href="https://pixelplumbing.com/" target="_blank">pixelplumbing.com<a>',
       plugins: [
         docuteGoogleAnalytics('UA-13034748-12'),
-        docuteApiTitlePlugin
+        docuteApiTitlePlugin,
+        docuteApiSearchPlugin
       ],
-      sourcePath: 'https://cdn.jsdelivr.net/gh/lovell/sharp@v0.24.0/docs',
+      sourcePath: 'https://cdn.jsdelivr.net/gh/lovell/sharp@v0.25.4/docs',
       nav: [
         {
           title: 'Funding',

docs/install.md

@@ -10,16 +10,17 @@ yarn add sharp
 
 ## Prerequisites
 
-* Node.js v10.13.0+
+* Node.js v10+
 
 ## Prebuilt binaries
 
 Ready-compiled sharp and libvips binaries are provided for use with
-Node.js versions 10, 12 and 13 on the most common platforms:
+Node.js v10+ on the most common platforms:
 
 * macOS x64 (>= 10.13)
 * Linux x64 (glibc >= 2.17, musl >= 1.1.24)
-* Windows x64 with 64-bit `node.exe`
+* Linux ARM64 (glibc >= 2.29)
+* Windows
 
 A ~10MB tarball containing libvips and its most commonly used dependencies
 is downloaded via HTTPS and stored within `node_modules/sharp/vendor` during `npm install`.
@@ -30,8 +31,7 @@ JPEG, PNG, WebP, TIFF, GIF (input) and SVG (input) image formats.
 The following platforms have prebuilt libvips but not sharp:
 
 * Linux ARMv6
-* Linux ARMv7
-* Linux ARM64 (glibc >= 2.29)
+* Linux ARMv7 (glibc >= 2.28)
 
 The following platforms require compilation of both libvips and sharp from source:
 
@@ -42,18 +42,15 @@ The following platforms require compilation of both libvips and sharp from sourc
 * FreeBSD
 * OpenBSD
 
-The following platforms are completely unsupported:
-
-* Windows x86
-* Windows x64 with 32-bit `node.exe`
-
 ## Common problems
 
-The platform and major version of Node.js used for `npm install`
-must be the same as the platform and major version of Node.js used at runtime.
+The architecture and platform of Node.js used for `npm install`
+must be the same as the architecture and platform of Node.js used at runtime.
 
 The `npm install --unsafe-perm` flag must be used when installing as `root` or a `sudo` user.
 
+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.
 
 ## Custom libvips
@@ -77,31 +74,48 @@ This module will be compiled from source at `npm install` time when:
 
 Building from source requires:
 
-* C++11 compatible compiler such as gcc 4.8+, clang 3.0+ or MSVC 2013+
-* [node-gyp](https://github.com/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
 
 ## Custom prebuilt binaries
 
 This is an advanced approach that most people will not require.
 
-To install the prebuilt libvips binaries from a custom URL,
-set the `sharp_dist_base_url` npm config option
-or the `SHARP_DIST_BASE_URL` environment variable.
+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.
 
-For example, both of the following will result in an attempt to download the file located at
-`https://hostname/path/libvips-x.y.z-platform.tar.gz`.
+To install the prebuilt libvips binaries from a custom URL,
+set the `sharp_libvips_binary_host` npm config option
+or the `npm_config_sharp_libvips_binary_host` environment variable.
+
+The version subpath and file name are appended to these.
+
+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.gz`.
+
+See the Chinese mirror below for a further example.
+
+## Chinese mirror
+
+Alibaba provide a mirror site based in China containing binaries for both sharp and libvips.
+
+To use this either set the following configuration:
 
 ```sh
-npm config set sharp_dist_base_url "https://hostname/path/"
+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
 ```
 
-```sh
-SHARP_DIST_BASE_URL="https://hostname/path/" npm install sharp
-```
+or set the following environment variables:
 
-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)
+```sh
+npm_config_sharp_binary_host="https://npm.taobao.org/mirrors/sharp" \
+  npm_config_sharp_libvips_binary_host "https://npm.taobao.org/mirrors/sharp-libvips" \
+  npm install sharp
+```
 
 ## FreeBSD
 
@@ -127,24 +141,24 @@ to `false` when using the `yarn` package manager.
 
 ## AWS Lambda
 
-Set the Lambda runtime to `nodejs10.x`.
+Set the Lambda runtime to `nodejs12.x`.
 
 The binaries in the `node_modules` directory of the
-[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html)
+[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-package.html)
 must be for the Linux x64 platform.
 
 On machines other than Linux x64, such as macOS and Windows, run the following:
 
 ```sh
 rm -rf node_modules/sharp
-npm install --arch=x64 --platform=linux --target=10.15.0 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.

docs/robots.txt

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

docs/search-index/build.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('fs');
+const { extractDescription, extractKeywords } = require('./extract');
+
+const searchIndex = [];
+
+// Install
+const contents = fs.readFileSync(`${__dirname}/../install.md`, 'utf8');
+const matches = contents.matchAll(
+  /## (?<title>[A-Za-z ]+)\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(`${__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(
+  `${__dirname}/../search-index.json`,
+  JSON.stringify(searchIndex)
+);

docs/search-index/extract.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const stopWords = [
+  'a',
+  'about',
+  'all',
+  'already',
+  'always',
+  'an',
+  'and',
+  'any',
+  'are',
+  'as',
+  'at',
+  'be',
+  'been',
+  'by',
+  'can',
+  'do',
+  'does',
+  'each',
+  'either',
+  'etc',
+  'for',
+  'from',
+  'get',
+  'gets',
+  'has',
+  'have',
+  'how',
+  'if',
+  'in',
+  'is',
+  'it',
+  'its',
+  'may',
+  'more',
+  'much',
+  'no',
+  'not',
+  'of',
+  'on',
+  'or',
+  'over',
+  'set',
+  'sets',
+  'should',
+  'that',
+  'the',
+  'their',
+  'there',
+  'therefore',
+  'these',
+  'this',
+  'to',
+  'use',
+  'using',
+  'when',
+  'which',
+  'will',
+  'with'
+];
+
+const extractDescription = (str) =>
+  str
+    .replace(/\(http[^)]+/g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
+    .replace(/\s+/g, ' ')
+    .substr(0, 140)
+    .trim();
+
+const extractKeywords = (str) =>
+  str
+    .split(/[ -/]/)
+    .map((word) => word.toLowerCase().replace(/[^a-z]/g, ''))
+    .filter((word) => word.length > 2 && !stopWords.includes(word))
+    .join(' ');
+
+module.exports = { extractDescription, extractKeywords };

install/dll-copy.js

@@ -6,7 +6,8 @@ const path = require('path');
 const libvips = require('../lib/libvips');
 const npmLog = require('npmlog');
 
-if (process.platform === 'win32') {
+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}`);

install/libvips.js

@@ -14,8 +14,15 @@ 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 { 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 fail = function (err) {
   npmLog.error('sharp', err.message);
@@ -57,18 +64,14 @@ try {
     // 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 === '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) {
-      const minimumGlibcVersion = arch === 'arm64' ? '2.29.0' : '2.17.0';
-      if (semver.lt(`${detectLibc.version}.0`, minimumGlibcVersion)) {
+      if (semver.lt(`${detectLibc.version}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
         throw new Error(`Use with glibc ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
       }
     }

lib/channel.js

@@ -54,27 +54,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;
 }
@@ -90,7 +88,7 @@ function extractChannel (channel) {
  * Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data.
  * For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
  *
- * @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
@@ -118,7 +116,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,7 @@ function grayscale (grayscale) {
 /**
  * Set the output colourspace.
  * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
- * @param {String} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+ * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -71,7 +71,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 +82,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

@@ -72,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]
@@ -100,8 +100,7 @@ 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',

lib/constructor.js

@@ -16,6 +16,8 @@ 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 if (/Cannot find module/.test(err.message)) {
     help.push('- Run "npm rebuild --verbose sharp" and look for errors');
   } else {
@@ -36,15 +38,20 @@ try {
 const debuglog = util.debuglog('sharp');
 
 /**
- * @constructs 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.
  * 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)
@@ -79,30 +86,31 @@ const debuglog = util.debuglog('sharp');
  * .toBuffer()
  * .then( ... );
  *
- * @param {(Buffer|String)} [input] - if present, can be
+ * @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.
  * @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|Boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
+ * @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.
+ * @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.
- * @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} [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} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
- * @param {Number} [options.raw.width]
- * @param {Number} [options.raw.height]
- * @param {Number} [options.raw.channels] - 1-4
+ * @param {number} [options.raw.width]
+ * @param {number} [options.raw.height]
+ * @param {number} [options.raw.channels] - 1-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]
+ * @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.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -161,7 +169,7 @@ const Sharp = function (input, options) {
     gamma: 0,
     gammaOut: 0,
     greyscale: false,
-    normalise: 0,
+    normalise: false,
     brightness: 1,
     saturation: 1,
     hue: 0,
@@ -217,12 +225,20 @@ const Sharp = function (input, options) {
     heifCompression: 'hevc',
     tileSize: 256,
     tileOverlap: 0,
+    tileContainer: 'fs',
+    tileLayout: 'dz',
+    tileFormat: 'last',
+    tileDepth: 'last',
+    tileAngle: 0,
     tileSkipBlanks: -1,
     tileBackground: [255, 255, 255, 255],
     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) {
       Sharp.queue.emit('change', queueLength);
@@ -246,6 +262,54 @@ util.inherits(Sharp, stream.Duplex);
  * // firstWritableStream receives auto-rotated, resized readableStream
  * // secondWritableStream receives auto-rotated, extracted region of readableStream
  *
+ * @example
+ * // Create a pipeline that will download an image, resize it and format it to different files
+ * // Using Promises to know when the pipeline is complete
+ * const fs = require("fs");
+ * const got = require("got");
+ * const sharpStream = sharp({
+ *   failOnError: false
+ * });
+ *
+ * const promises = [];
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .jpeg({ quality: 100 })
+ *     .toFile("originalFile.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .jpeg({ quality: 80 })
+ *     .toFile("optimized-500.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .webp({ quality: 80 })
+ *     .toFile("optimized-500.webp")
+ * );
+ *
+ * // https://github.com/sindresorhus/got#gotstreamurl-options
+ * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
+ *
+ * Promise.all(promises)
+ *   .then(res => { console.log("Done!", res); })
+ *   .catch(err => {
+ *     console.error("Error processing files, let's clean it up", err);
+ *     try {
+ *       fs.unlinkSync("originalFile.jpg");
+ *       fs.unlinkSync("optimized-500.jpg");
+ *       fs.unlinkSync("optimized-500.webp");
+ *     } catch (e) {}
+ *   });
+ *
  * @returns {Sharp}
  */
 function clone () {

lib/input.js

@@ -1,10 +1,20 @@
 'use strict';
 
-const util = require('util');
 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 } = obj;
+  return [raw, density, limitInputPixels, sequentialRead, failOnError].some(is.defined)
+    ? { raw, density, limitInputPixels, sequentialRead, failOnError }
+    : undefined;
+}
+
 /**
  * Create Object containing input and input-related options.
  * @private
@@ -24,12 +34,12 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
     inputOptions = input;
-    if (is.plainObject(inputOptions.raw) || is.bool(inputOptions.failOnError)) {
-      // Raw Stream
+    if (_inputOptionsFromObject(inputOptions)) {
+      // Stream with options
       inputDescriptor.buffer = [];
     }
   } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
-    // Stream
+    // Stream without options
     inputDescriptor.buffer = [];
   } else {
     throw new Error(`Unsupported input '${input}' of type ${typeof input}${
@@ -103,6 +113,14 @@ 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);
+      }
+    }
     // Create new image
     if (is.defined(inputOptions.create)) {
       if (
@@ -137,7 +155,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) {
@@ -173,7 +191,7 @@ function _flattenBufferIn () {
 /**
  * Are we expecting Stream-based input?
  * @private
- * @returns {Boolean}
+ * @returns {boolean}
  */
 function _isStreamInput () {
   return Array.isArray(this.options.input.buffer);
@@ -187,9 +205,9 @@ function _isStreamInput () {
  * - `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
@@ -198,6 +216,7 @@ function _isStreamInput () {
  * - `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
  * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
  * - `pagePrimary`: Number of the primary page in a HEIF image
+ * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
  * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
  * - `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
  * - `orientation`: Number value of the EXIF Orientation header, if present
@@ -278,8 +297,9 @@ 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)
  *
  * @example
  * const image = sharp(inputJpg);
@@ -289,6 +309,9 @@ function metadata (callback) {
  *      // stats contains the channel-wise statistics array and the isOpaque value
  *   });
  *
+ * @example
+ * const { entropy, sharpness } = await sharp(input).stats();
+ *
  * @param {Function} [callback] - called with the arguments `(err, stats)`
  * @returns {Promise<Object>}
  */
@@ -331,32 +354,6 @@ function stats (callback) {
   }
 }
 
-/**
- * @private
- */
-const limitInputPixels = util.deprecate(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.input.limitInputPixels = limit;
-  } else {
-    throw is.invalidParameterError('limitInputPixels', 'integer', limit);
-  }
-  return this;
-}, 'limitInputPixels is deprecated, use sharp(input, { limitInputPixels: false }) instead');
-
-/**
- * @private
- */
-const sequentialRead = util.deprecate(function sequentialRead (sequentialRead) {
-  this.options.input.sequentialRead = is.bool(sequentialRead) ? sequentialRead : true;
-  return this;
-}, 'sequentialRead is deprecated, use sharp(input, { sequentialRead: true }) instead');
-
 /**
  * Decorate the Sharp prototype with input-related functions.
  * @private
@@ -364,15 +361,13 @@ const sequentialRead = util.deprecate(function sequentialRead (sequentialRead) {
 module.exports = function (Sharp) {
   Object.assign(Sharp.prototype, {
     // Private
+    _inputOptionsFromObject,
     _createInputDescriptor,
     _write,
     _flattenBufferIn,
     _isStreamInput,
     // Public
     metadata,
-    stats,
-    // Deprecated
-    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,7 @@ const bool = function (val) {
  * @private
  */
 const buffer = function (val) {
-  return object(val) && val instanceof Buffer;
+  return val instanceof Buffer;
 };
 
 /**
@@ -69,7 +69,7 @@ const number = function (val) {
  * @private
  */
 const integer = function (val) {
-  return number(val) && val % 1 === 0;
+  return Number.isInteger(val);
 };
 
 /**
@@ -85,14 +85,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

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',
@@ -64,7 +65,7 @@ const hasVendoredLibvips = function () {
     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;
@@ -93,11 +94,12 @@ const useGlobalLibvips = function () {
 };
 
 module.exports = {
-  minimumLibvipsVersion: minimumLibvipsVersion,
-  cachePath: cachePath,
-  globalLibvipsVersion: globalLibvipsVersion,
-  hasVendoredLibvips: hasVendoredLibvips,
-  pkgConfigPath: pkgConfigPath,
-  useGlobalLibvips: useGlobalLibvips,
-  mkdirSync: mkdirSync
+  minimumLibvipsVersion,
+  minimumLibvipsVersionLabelled,
+  cachePath,
+  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
  */
@@ -88,9 +88,9 @@ function flop (flop) {
  * 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 +129,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 +150,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
  */
@@ -173,7 +173,7 @@ function blur (sigma) {
 /**
  * Merge alpha transparency channel, if any, with a background.
  * @param {Object} [options]
- * @param {String|Object} [options.background={r: 0, g: 0, b: 0}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black.
+ * @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 +193,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 +264,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
  */
@@ -300,7 +300,7 @@ function convolve (kernel) {
 
 /**
  * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
- * @param {Number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
+ * @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 +331,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 +353,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
  */
@@ -394,7 +394,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
  */
@@ -440,9 +440,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) {

lib/output.js

@@ -36,7 +36,7 @@ const formats = new Map([
  *   .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).
@@ -103,7 +103,7 @@ function toFile (fileOut, callback) {
  *   .catch(err => { ... });
  *
  * @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
  */
@@ -118,9 +118,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.
  *
+ * The default behaviour, when `withMetadata` is not used, is to convert to the device-independent
+ * sRGB colour space and strip all metadata, including the removal of any ICC profile.
+ *
  * @example
  * sharp('input.jpg')
  *   .withMetadata()
@@ -128,7 +130,7 @@ function toBuffer (options, callback) {
  *   .then(info => { ... });
  *
  * @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.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -155,7 +157,7 @@ function withMetadata (options) {
  *   .toFormat('png')
  *   .toBuffer();
  *
- * @param {(String|Object)} format - as a String or an Object with an 'id' attribute
+ * @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
@@ -171,6 +173,8 @@ function toFormat (format, options) {
 /**
  * Use these JPEG options for output image.
  *
+ * Some of these options require the use of a globally-installed libvips compiled with support for mozjpeg.
+ *
  * @example
  * // Convert any input to very high quality JPEG output
  * const data = await sharp(input)
@@ -181,18 +185,18 @@ function toFormat (format, options) {
  *   .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'] - for quality < 90, set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' (use chroma subsampling); for quality >= 90 chroma is never subsampled
+ * @param {boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
+ * @param {boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
+ * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans, requires libvips compiled with support for mozjpeg
+ * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8, requires libvips compiled with support for mozjpeg
+ * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable, requires libvips compiled with support for mozjpeg
+ * @param {boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -251,6 +255,8 @@ function jpeg (options) {
  * PNG output is always full colour at 8 or 16 bits per pixel.
  * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
  *
+ * Some of these options require the use of a globally-installed libvips compiled with support for libimagequant (GPL).
+ *
  * @example
  * // Convert any input to PNG output
  * const data = await sharp(input)
@@ -258,15 +264,15 @@ function jpeg (options) {
  *   .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=9] - zlib compression level, 0-9
+ * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
+ * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support, requires libvips compiled with support for libimagequant
+ * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`, requires libvips compiled with support for libimagequant
+ * @param {boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -287,28 +293,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);
         }
       }
     }
@@ -326,13 +334,13 @@ function png (options) {
  *   .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 {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -384,17 +392,17 @@ function webp (options) {
  *   .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 {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
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -480,9 +488,9 @@ function tiff (options) {
  * @since 0.23.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=80] - quality, integer 1-100
+ * @param {boolean} [options.compression='hevc'] - compression format: hevc, avc, jpeg, av1
+ * @param {boolean} [options.lossless=false] - use lossless compression
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -517,7 +525,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
@@ -525,6 +535,15 @@ 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 () {
@@ -550,14 +569,14 @@ function raw () {
  *   });
  *
  * @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`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -592,10 +611,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,
@@ -640,9 +659,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) {
@@ -653,10 +672,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) {

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
@@ -181,8 +190,8 @@ const mapFitToCanvas = {
  *     .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 {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.
@@ -293,11 +302,11 @@ 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]
+ * @param {(number|Object)} extend - single pixel count to add to all edges or an Object with per-edge counts
+ * @param {number} [extend.top]
+ * @param {number} [extend.left]
+ * @param {number} [extend.bottom]
+ * @param {number} [extend.right]
  * @param {String|Object} [extend.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -327,7 +336,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.
@@ -349,10 +358,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
  */
@@ -367,7 +376,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;
@@ -379,7 +388,7 @@ function extract (options) {
  *
  * The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` properties.
  *
- * @param {Number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
+ * @param {number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -391,6 +400,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

@@ -39,10 +39,10 @@ try {
  * 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) {
@@ -77,8 +77,8 @@ 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);
@@ -124,8 +124,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);

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.24.0",
+  "version": "0.25.4",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -65,17 +65,19 @@
     "Andargor <andargor@yahoo.com>",
     "Paul Neave <paul.neave@gmail.com>",
     "Brendan Kennedy <brenwken@gmail.com>",
-    "Brychan Bennett-Odlum <git@brychan.io>"
+    "Brychan Bennett-Odlum <git@brychan.io>",
+    "Edward Silverton <e.silverton@gmail.com>",
+    "Roman Malieiev <aromaleev@gmail.com>"
   ],
   "scripts": {
-    "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node-gyp rebuild && node install/dll-copy)",
+    "install": "(node install/libvips && node install/dll-copy && prebuild-install --runtime=napi) || (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-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-coverage": "./test/coverage/report.sh",
     "test-leak": "./test/leak/leak.sh",
-    "docs-build": "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 && for m in constructor input resize composite operation colour channel output utility; do documentation build --shallow --format=md --markdown-toc=false lib/$m.js >docs/api-$m.md; done && node docs/search-index/build",
     "docs-serve": "cd docs && npx serve",
     "docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
   },
@@ -109,40 +111,45 @@
   "dependencies": {
     "color": "^3.1.2",
     "detect-libc": "^1.0.3",
-    "nan": "^2.14.0",
+    "node-addon-api": "^3.0.0",
     "npmlog": "^4.1.2",
-    "prebuild-install": "^5.3.3",
-    "semver": "^7.1.1",
-    "simple-get": "^3.1.0",
-    "tar": "^5.0.5",
+    "prebuild-install": "^5.3.4",
+    "semver": "^7.3.2",
+    "simple-get": "^4.0.0",
+    "tar": "^6.0.2",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^3.1.0",
+    "async": "^3.2.0",
     "cc": "^2.0.1",
     "decompress-zip": "^0.3.2",
-    "documentation": "^12.1.4",
+    "documentation": "^13.0.1",
     "exif-reader": "^1.0.3",
     "icc": "^1.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^7.0.0",
-    "mock-fs": "^4.10.4",
-    "nyc": "^15.0.0",
+    "mocha": "^8.0.1",
+    "mock-fs": "^4.12.0",
+    "nyc": "^15.1.0",
     "prebuild": "^10.0.0",
     "prebuild-ci": "^3.1.0",
-    "rimraf": "^3.0.0",
+    "rimraf": "^3.0.2",
     "semistandard": "^14.2.0"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.9.0"
+    "libvips": "8.9.1"
   },
   "engines": {
-    "node": ">=10.13.0"
+    "node": ">=10"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"
   },
+  "binary": {
+    "napi_versions": [
+      3
+    ]
+  },
   "semistandard": {
     "env": [
       "mocha"

src/common.cc

@@ -19,9 +19,7 @@
 #include <queue>
 #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,66 +28,81 @@ 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);
+  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();
+  }
+  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> AttrAsRgba(Napi::Object obj, std::string attr) {
+    Napi::Array background = obj.Get(attr).As<Napi::Array>();
+    std::vector<double> rgba(background.Length());
+    for (unsigned int i = 0; i < background.Length(); i++) {
+      rgba[i] = AttrAsDouble(background, i);
     }
     return rgba;
   }
 
-  // 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");
     }
     // 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->createChannels = AttrAsUint32(input, "createChannels");
+      descriptor->createWidth = AttrAsUint32(input, "createWidth");
+      descriptor->createHeight = AttrAsUint32(input, "createHeight");
       descriptor->createBackground = AttrAsRgba(input, "createBackground");
     }
     // Limit input images to a given number of pixels, where pixels = width * height
-    descriptor->limitInputPixels = AttrTo<uint32_t>(input, "limitInputPixels");
+    descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
     // Allow switch from random to sequential access
-    descriptor->access = AttrTo<bool>(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
     return descriptor;
   }
 
@@ -270,6 +283,9 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
+            if (imageType == ImageType::SVG) {
+              option->set("unlimited", TRUE);
+            }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
               option->set("dpi", descriptor->density);
             }
@@ -280,6 +296,9 @@ namespace sharp {
               option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
             image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -316,6 +335,9 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
+            if (imageType == ImageType::SVG) {
+              option->set("unlimited", TRUE);
+            }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
               option->set("dpi", descriptor->density);
             }
@@ -326,6 +348,9 @@ namespace sharp {
               option->set("n", descriptor->pages);
               option->set("page", descriptor->page);
             }
+            if (imageType == ImageType::OPENSLIDE) {
+              option->set("level", descriptor->level);
+            }
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -439,11 +464,9 @@ namespace sharp {
   /*
     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

src/common.h

@@ -19,14 +19,13 @@
 #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 < 9))
-#error "libvips version 8.9.0+ is required - please see https://sharp.pixelplumbing.com/install"
+#error "libvips version 8.9.1+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -58,6 +57,7 @@ namespace sharp {
     int rawHeight;
     int pages;
     int page;
+    int level;
     int createChannels;
     int createWidth;
     int createHeight;
@@ -76,29 +76,25 @@ namespace sharp {
       rawHeight(0),
       pages(1),
       page(0),
+      level(0),
       createChannels(0),
       createWidth(0),
       createHeight(0),
       createBackground{ 0.0, 0.0, 0.0, 255.0 } {}
   };
 
-  // Convenience methods to access the attributes of a v8::Object
-  bool HasAttr(v8::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);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, std::string 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> AttrAsRgba(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,
@@ -211,7 +207,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

src/metadata.cc

@@ -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() {
@@ -86,6 +74,15 @@ class MetadataWorker : public Nan::AsyncWorker {
       if (image.get_typeof("heif-primary") == G_TYPE_INT) {
         baton->pagePrimary = image.get_int("heif-primary");
       }
+      if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
+        int const levels = std::stoi(image.get_string("openslide.level-count"));
+        for (int l = 0; l < levels; l++) {
+          std::string prefix = "openslide.level[" + std::to_string(l) + "].";
+          int const width = std::stoi(image.get_string((prefix + "width").data()));
+          int const height = std::stoi(image.get_string((prefix + "height").data()));
+          baton->levels.push_back(std::pair<int, int>(width, height));
+        }
+      }
       baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -137,140 +134,126 @@ 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->loop >= 0) {
-        Set(info, New("loop").ToLocalChecked(), New<v8::Uint32>(baton->loop));
-      }
-      if (!baton->delay.empty()) {
-        int i = 0;
-        v8::Local<v8::Array> delay = New<v8::Array>(baton->delay.size());
-        for (int const d : baton->delay) {
-          Set(delay, i++, New<v8::Number>(d));
-        }
-        Set(info, New("delay").ToLocalChecked(), delay);
-      }
-      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->levels.empty()) {
+        int i = 0;
+        Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
+        for (std::pair<int, int> const l : baton->levels) {
+          Napi::Object level = Napi::Object::New(env);
+          level.Set("width", l.first);
+          level.Set("height", l.second);
+          levels.Set(i++, level);
+        }
+        info.Set("levels", levels);
+      }
+      info.Set("hasProfile", baton->hasProfile);
+      info.Set("hasAlpha", baton->hasAlpha);
+      if (baton->orientation > 0) {
+        info.Set("orientation", baton->orientation);
+      }
+      if (baton->exifLength > 0) {
+        info.Set("exif", Napi::Buffer<char>::New(env, baton->exif, baton->exifLength, sharp::FreeCallback));
+      }
+      if (baton->iccLength > 0) {
+        info.Set("icc", Napi::Buffer<char>::New(env, baton->icc, baton->iccLength, sharp::FreeCallback));
+      }
+      if (baton->iptcLength > 0) {
+        info.Set("iptc", Napi::Buffer<char>::New(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
+      }
+      if (baton->xmpLength > 0) {
+        info.Set("xmp", Napi::Buffer<char>::New(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
+      }
+      if (baton->tifftagPhotoshopLength > 0) {
+        info.Set("tifftagPhotoshop",
+          Napi::Buffer<char>::New(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback));
+      }
+      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
+    }
+
+    delete baton->input;
+    delete baton;
   }
 
  private:
   MetadataBaton* baton;
-  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

@@ -16,7 +16,7 @@
 #define SRC_METADATA_H_
 
 #include <string>
-#include <nan.h>
+#include <napi.h>
 
 #include "./common.h"
 
@@ -39,6 +39,7 @@ struct MetadataBaton {
   int loop;
   std::vector<int> delay;
   int pagePrimary;
+  std::vector<std::pair<int, int>> levels;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -81,6 +82,6 @@ struct MetadataBaton {
     tifftagPhotoshopLength(0) {}
 };
 
-NAN_METHOD(metadata);
+Napi::Value metadata(const Napi::CallbackInfo& info);
 
 #endif  // SRC_METADATA_H_

src/pipeline.cc

@@ -25,8 +25,7 @@
 #include <sys/stat.h>
 
 #include <vips/vips8>
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
 
 #include "common.h"
 #include "operations.h"
@@ -46,28 +45,18 @@
 #define STAT64_FUNCTION stat64
 #endif
 
-class PipelineWorker : public Nan::AsyncWorker {
+class PipelineWorker : public Napi::AsyncWorker {
  public:
-  PipelineWorker(
-    Nan::Callback *callback, PipelineBaton *baton, Nan::Callback *debuglog, Nan::Callback *queueListener,
-    std::vector<v8::Local<v8::Object>> const buffersToPersist) :
-    Nan::AsyncWorker(callback, "sharp:PipelineWorker"),
-    baton(baton), debuglog(debuglog), queueListener(queueListener),
-    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;
-      });
-  }
+  PipelineWorker(Napi::Function callback, PipelineBaton *baton,
+    Napi::Function debuglog, Napi::Function queueListener) :
+    Napi::AsyncWorker(callback),
+    baton(baton),
+    debuglog(Napi::Persistent(debuglog)),
+    queueListener(Napi::Persistent(queueListener)) {}
   ~PipelineWorker() {}
 
   // libuv worker
   void Execute() {
-    using sharp::HasAlpha;
-    using sharp::ImageType;
-
     // Decrement queued task counter
     g_atomic_int_dec_and_test(&sharp::counterQueue);
     // Increment processing task counter
@@ -76,7 +65,7 @@ class PipelineWorker : public Nan::AsyncWorker {
     try {
       // Open input
       vips::VImage image;
-      ImageType inputImageType;
+      sharp::ImageType inputImageType;
       std::tie(image, inputImageType) = sharp::OpenInput(baton->input);
 
       // Calculate angle of rotation
@@ -236,7 +225,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       }
       if (
         xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
-        (inputImageType == ImageType::JPEG || inputImageType == ImageType::WEBP) &&
+        (inputImageType == sharp::ImageType::JPEG || inputImageType == sharp::ImageType::WEBP) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0
       ) {
         if (xshrink >= 8 * shrink_on_load_factor) {
@@ -267,7 +256,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           ->set("fail", baton->input->failOnError);
         if (baton->input->buffer != nullptr) {
           VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
-          if (inputImageType == ImageType::JPEG) {
+          if (inputImageType == sharp::ImageType::JPEG) {
             // Reload JPEG buffer
             image = VImage::jpegload_buffer(blob, option);
           } else {
@@ -276,7 +265,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           }
           vips_area_unref(reinterpret_cast<VipsArea*>(blob));
         } else {
-          if (inputImageType == ImageType::JPEG) {
+          if (inputImageType == sharp::ImageType::JPEG) {
             // Reload JPEG file
             image = VImage::jpegload(const_cast<char*>(baton->input->file.data()), option);
           } else {
@@ -320,7 +309,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       }
 
       // Flatten image to remove alpha channel
-      if (baton->flatten && HasAlpha(image)) {
+      if (baton->flatten && sharp::HasAlpha(image)) {
         // Scale up 8-bit values to match 16-bit input image
         double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
         // Background colour
@@ -356,11 +345,11 @@ class PipelineWorker : public Nan::AsyncWorker {
       bool const shouldComposite = !baton->composite.empty();
       bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0;
 
-      if (shouldComposite && !HasAlpha(image)) {
+      if (shouldComposite && !sharp::HasAlpha(image)) {
         image = sharp::EnsureAlpha(image);
       }
 
-      bool const shouldPremultiplyAlpha = HasAlpha(image) &&
+      bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
         (shouldResize || shouldBlur || shouldConv || shouldSharpen || shouldComposite);
 
       // Premultiply image alpha channel before all transformations to avoid
@@ -416,7 +405,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Join additional color channels to the image
       if (baton->joinChannelIn.size() > 0) {
         VImage joinImage;
-        ImageType joinImageType = ImageType::UNKNOWN;
+        sharp::ImageType joinImageType = sharp::ImageType::UNKNOWN;
 
         for (unsigned int i = 0; i < baton->joinChannelIn.size(); i++) {
           std::tie(joinImage, joinImageType) = sharp::OpenInput(baton->joinChannelIn[i]);
@@ -548,7 +537,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       if (shouldComposite) {
         for (Composite *composite : baton->composite) {
           VImage compositeImage;
-          ImageType compositeImageType = ImageType::UNKNOWN;
+          sharp::ImageType compositeImageType = sharp::ImageType::UNKNOWN;
           std::tie(compositeImage, compositeImageType) = OpenInput(composite->input);
           // Verify within current dimensions
           if (compositeImage.width() > image.width() || compositeImage.height() > image.height()) {
@@ -584,7 +573,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           }
           // Ensure image to composite is sRGB with premultiplied alpha
           compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
-          if (!HasAlpha(compositeImage)) {
+          if (!sharp::HasAlpha(compositeImage)) {
             compositeImage = sharp::EnsureAlpha(compositeImage);
           }
           if (!composite->premultiplied) compositeImage = compositeImage.premultiply();
@@ -638,7 +627,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Apply bitwise boolean operation between images
       if (baton->boolean != nullptr) {
         VImage booleanImage;
-        ImageType booleanImageType = ImageType::UNKNOWN;
+        sharp::ImageType booleanImageType = sharp::ImageType::UNKNOWN;
         std::tie(booleanImage, booleanImageType) = sharp::OpenInput(baton->boolean);
         image = sharp::Boolean(image, booleanImage, baton->booleanOp);
       }
@@ -656,8 +645,12 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Extract an image channel (aka vips band)
       if (baton->extractChannel > -1) {
         if (baton->extractChannel >= image.bands()) {
-          (baton->err).append("Cannot extract channel from image. Too few channels in image.");
-          return Error();
+          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
+            baton->extractChannel = image.bands() - 1;
+          } else {
+            (baton->err).append("Cannot extract channel from image. Too few channels in image.");
+            return Error();
+          }
         }
         VipsInterpretation const interpretation = sharp::Is16Bit(image.interpretation())
           ? VIPS_INTERPRETATION_GREY16
@@ -703,9 +696,9 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Output
       if (baton->fileOut.empty()) {
         // Buffer output
-        if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == ImageType::JPEG)) {
+        if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to buffer
-          sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
           VipsArea *area = VIPS_AREA(image.jpegsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->jpegQuality)
@@ -727,9 +720,10 @@ class PipelineWorker : public Nan::AsyncWorker {
             baton->channels = std::min(baton->channels, 3);
           }
         } else if (baton->formatOut == "png" || (baton->formatOut == "input" &&
-          (inputImageType == ImageType::PNG || inputImageType == ImageType::GIF || inputImageType == ImageType::SVG))) {
+          (inputImageType == sharp::ImageType::PNG || inputImageType == sharp::ImageType::GIF ||
+            inputImageType == sharp::ImageType::SVG))) {
           // Write PNG to buffer
-          sharp::AssertImageTypeDimensions(image, ImageType::PNG);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::PNG);
           VipsArea *area = VIPS_AREA(image.pngsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("interlace", baton->pngProgressive)
@@ -744,9 +738,10 @@ class PipelineWorker : public Nan::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "png";
-        } else if (baton->formatOut == "webp" || (baton->formatOut == "input" && inputImageType == ImageType::WEBP)) {
+        } else if (baton->formatOut == "webp" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::WEBP)) {
           // Write WEBP to buffer
-          sharp::AssertImageTypeDimensions(image, ImageType::WEBP);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::WEBP);
           VipsArea *area = VIPS_AREA(image.webpsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->webpQuality)
@@ -760,10 +755,12 @@ class PipelineWorker : public Nan::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "webp";
-        } else if (baton->formatOut == "tiff" || (baton->formatOut == "input" && inputImageType == ImageType::TIFF)) {
+        } else if (baton->formatOut == "tiff" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::TIFF)) {
           // Write TIFF to buffer
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
-            sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
+            sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
+            baton->channels = std::min(baton->channels, 3);
           }
           // Cast pixel values to float, if required
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
@@ -786,8 +783,8 @@ class PipelineWorker : public Nan::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "tiff";
-          baton->channels = std::min(baton->channels, 3);
-        } else if (baton->formatOut == "heif" || (baton->formatOut == "input" && inputImageType == ImageType::HEIF)) {
+        } else if (baton->formatOut == "heif" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to buffer
           VipsArea *area = VIPS_AREA(image.heifsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
@@ -799,7 +796,8 @@ class PipelineWorker : public Nan::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "heif";
-        } else if (baton->formatOut == "raw" || (baton->formatOut == "input" && inputImageType == ImageType::RAW)) {
+        } else if (baton->formatOut == "raw" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::RAW)) {
           // Write raw, uncompressed image data to buffer
           if (baton->greyscale || image.interpretation() == VIPS_INTERPRETATION_B_W) {
             // Extract first band for greyscale image
@@ -840,9 +838,9 @@ class PipelineWorker : public Nan::AsyncWorker {
         bool const mightMatchInput = baton->formatOut == "input";
         bool const willMatchInput = mightMatchInput && !(isJpeg || isPng || isWebp || isTiff || isDz || isDzZip || isV);
         if (baton->formatOut == "jpeg" || (mightMatchInput && isJpeg) ||
-          (willMatchInput && inputImageType == ImageType::JPEG)) {
+          (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to file
-          sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
           image.jpegsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->jpegQuality)
@@ -856,9 +854,10 @@ class PipelineWorker : public Nan::AsyncWorker {
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
         } else if (baton->formatOut == "png" || (mightMatchInput && isPng) || (willMatchInput &&
-          (inputImageType == ImageType::PNG || inputImageType == ImageType::GIF || inputImageType == ImageType::SVG))) {
+          (inputImageType == sharp::ImageType::PNG || inputImageType == sharp::ImageType::GIF ||
+            inputImageType == sharp::ImageType::SVG))) {
           // Write PNG to file
-          sharp::AssertImageTypeDimensions(image, ImageType::PNG);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::PNG);
           image.pngsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("interlace", baton->pngProgressive)
@@ -870,9 +869,9 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("dither", baton->pngDither));
           baton->formatOut = "png";
         } else if (baton->formatOut == "webp" || (mightMatchInput && isWebp) ||
-          (willMatchInput && inputImageType == ImageType::WEBP)) {
+          (willMatchInput && inputImageType == sharp::ImageType::WEBP)) {
           // Write WEBP to file
-          sharp::AssertImageTypeDimensions(image, ImageType::WEBP);
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::WEBP);
           image.webpsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->webpQuality)
@@ -883,10 +882,11 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("alpha_q", baton->webpAlphaQuality));
           baton->formatOut = "webp";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
-          (willMatchInput && inputImageType == ImageType::TIFF)) {
+          (willMatchInput && inputImageType == sharp::ImageType::TIFF)) {
           // Write TIFF to file
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
-            sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
+            sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
+            baton->channels = std::min(baton->channels, 3);
           }
           image.tiffsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
@@ -901,9 +901,8 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("xres", baton->tiffXres)
             ->set("yres", baton->tiffYres));
           baton->formatOut = "tiff";
-          baton->channels = std::min(baton->channels, 3);
         } else if (baton->formatOut == "heif" || (mightMatchInput && isHeif) ||
-          (willMatchInput && inputImageType == ImageType::HEIF)) {
+          (willMatchInput && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to file
           if (sharp::IsAvif(baton->fileOut)) {
             baton->heifCompression = VIPS_FOREIGN_HEIF_COMPRESSION_AV1;
@@ -938,9 +937,6 @@ class PipelineWorker : public Nan::AsyncWorker {
             };
             suffix = AssembleSuffixString(".webp", options);
           } else {
-            std::string extname = baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_GOOGLE
-              || baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_ZOOMIFY
-                ? ".jpg" : ".jpeg";
             std::vector<std::pair<std::string, std::string>> options {
               {"Q", std::to_string(baton->jpegQuality)},
               {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
@@ -951,10 +947,11 @@ class PipelineWorker : public Nan::AsyncWorker {
               {"optimize_scans", baton->jpegOptimiseScans ? "TRUE": "FALSE"},
               {"optimize_coding", baton->jpegOptimiseCoding ? "TRUE": "FALSE"}
             };
+            std::string extname = baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_DZ ? ".jpeg" : ".jpg";
             suffix = AssembleSuffixString(extname, options);
           }
           // Remove alpha channel from tile background if image does not contain an alpha channel
-          if (!HasAlpha(image)) {
+          if (!sharp::HasAlpha(image)) {
             baton->tileBackground.pop_back();
           }
           // Write DZ to file
@@ -976,7 +973,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
-          (willMatchInput && inputImageType == ImageType::VIPS)) {
+          (willMatchInput && inputImageType == sharp::ImageType::VIPS)) {
           // Write V to file
           image.vipssave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata));
@@ -1000,16 +997,18 @@ class PipelineWorker : public Nan::AsyncWorker {
     vips_thread_shutdown();
   }
 
-  void HandleOKCallback() {
-    using Nan::New;
-    using Nan::Set;
-    Nan::HandleScope();
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
 
-    v8::Local<v8::Value> argv[3] = { Nan::Null(), Nan::Null(), Nan::Null() };
-    if (!baton->err.empty()) {
-      // Error
-      argv[0] = Nan::Error(baton->err.data());
-    } else {
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call({ Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
       int width = baton->width;
       int height = baton->height;
       if (baton->topOffsetPre != -1 && (baton->width == -1 || baton->height == -1)) {
@@ -1021,50 +1020,40 @@ class PipelineWorker : public Nan::AsyncWorker {
         height = baton->heightPost;
       }
       // Info Object
-      v8::Local<v8::Object> info = New<v8::Object>();
-      Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->formatOut).ToLocalChecked());
-      Set(info, New("width").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(width)));
-      Set(info, New("height").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(height)));
-      Set(info, New("channels").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(baton->channels)));
-      Set(info, New("premultiplied").ToLocalChecked(), New<v8::Boolean>(baton->premultiplied));
+      Napi::Object info = Napi::Object::New(env);
+      info.Set("format", baton->formatOut);
+      info.Set("width", static_cast<uint32_t>(width));
+      info.Set("height", static_cast<uint32_t>(height));
+      info.Set("channels", static_cast<uint32_t>(baton->channels));
+      info.Set("premultiplied", baton->premultiplied);
       if (baton->hasCropOffset) {
-        Set(info, New("cropOffsetLeft").ToLocalChecked(),
-          New<v8::Int32>(static_cast<int32_t>(baton->cropOffsetLeft)));
-        Set(info, New("cropOffsetTop").ToLocalChecked(),
-          New<v8::Int32>(static_cast<int32_t>(baton->cropOffsetTop)));
+        info.Set("cropOffsetLeft", static_cast<int32_t>(baton->cropOffsetLeft));
+        info.Set("cropOffsetTop", static_cast<int32_t>(baton->cropOffsetTop));
       }
       if (baton->trimThreshold > 0.0) {
-        Set(info, New("trimOffsetLeft").ToLocalChecked(),
-          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetLeft)));
-        Set(info, New("trimOffsetTop").ToLocalChecked(),
-          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetTop)));
+        info.Set("trimOffsetLeft", static_cast<int32_t>(baton->trimOffsetLeft));
+        info.Set("trimOffsetTop", static_cast<int32_t>(baton->trimOffsetTop));
       }
 
       if (baton->bufferOutLength > 0) {
-        // Pass ownership of output data to Buffer instance
-        argv[1] = Nan::NewBuffer(
-          static_cast<char*>(baton->bufferOut), baton->bufferOutLength, sharp::FreeCallback, nullptr)
-          .ToLocalChecked();
         // Add buffer size to info
-        Set(info, New("size").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(baton->bufferOutLength)));
-        argv[2] = info;
+        info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
+        // Pass ownership of output data to Buffer instance
+        Napi::Buffer<char> data = Napi::Buffer<char>::New(env, static_cast<char*>(baton->bufferOut),
+          baton->bufferOutLength, sharp::FreeCallback);
+        Callback().MakeCallback(Receiver().Value(), { env.Null(), data, info });
       } else {
         // Add file size to info
         struct STAT64_STRUCT st;
         if (STAT64_FUNCTION(baton->fileOut.data(), &st) == 0) {
-          Set(info, New("size").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(st.st_size)));
+          info.Set("size", static_cast<uint32_t>(st.st_size));
         }
-        argv[1] = info;
+        Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
       }
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
     }
 
-    // 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
     delete baton->input;
     delete baton->boolean;
@@ -1077,29 +1066,16 @@ class PipelineWorker : public Nan::AsyncWorker {
     }
     delete baton;
 
-    // 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);
-      warning = sharp::VipsWarningPop();
-    }
-
     // Decrement processing task counter
     g_atomic_int_dec_and_test(&sharp::counterProcess);
-    v8::Local<v8::Value> queueLength[1] = { New<v8::Uint32>(sharp::counterQueue) };
-    queueListener->Call(1, queueLength, async_resource);
-    delete queueListener;
-
-    // Return to JavaScript
-    callback->Call(3, argv, async_resource);
+    Napi::Number queueLength = Napi::Number::New(env, static_cast<double>(sharp::counterQueue));
+    queueListener.Call(Receiver().Value(), { queueLength });
   }
 
  private:
   PipelineBaton *baton;
-  Nan::Callback *debuglog;
-  Nan::Callback *queueListener;
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
+  Napi::FunctionReference debuglog;
+  Napi::FunctionReference queueListener;
 
   /*
     Calculate the angle of rotation and need-to-flip for the given Exif orientation
@@ -1169,37 +1145,27 @@ class PipelineWorker : public Nan::AsyncWorker {
 /*
   pipeline(options, output, callback)
 */
-NAN_METHOD(pipeline) {
-  using sharp::HasAttr;
-  using sharp::AttrTo;
-  using sharp::AttrAs;
-  using sharp::AttrAsStr;
-  using sharp::AttrAsRgba;
-  using sharp::CreateInputDescriptor;
-
-  // Input Buffers must not undergo GC compaction during processing
-  std::vector<v8::Local<v8::Object>> buffersToPersist;
-
+Napi::Value pipeline(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   PipelineBaton *baton = new PipelineBaton;
-  v8::Local<v8::Object> options = info[0].As<v8::Object>();
+  Napi::Object options = info[0].As<Napi::Object>();
 
   // Input
-  baton->input = CreateInputDescriptor(AttrAs<v8::Object>(options, "input"), buffersToPersist);
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
   // Extract image options
-  baton->topOffsetPre = AttrTo<int32_t>(options, "topOffsetPre");
-  baton->leftOffsetPre = AttrTo<int32_t>(options, "leftOffsetPre");
-  baton->widthPre = AttrTo<int32_t>(options, "widthPre");
-  baton->heightPre = AttrTo<int32_t>(options, "heightPre");
-  baton->topOffsetPost = AttrTo<int32_t>(options, "topOffsetPost");
-  baton->leftOffsetPost = AttrTo<int32_t>(options, "leftOffsetPost");
-  baton->widthPost = AttrTo<int32_t>(options, "widthPost");
-  baton->heightPost = AttrTo<int32_t>(options, "heightPost");
+  baton->topOffsetPre = sharp::AttrAsInt32(options, "topOffsetPre");
+  baton->leftOffsetPre = sharp::AttrAsInt32(options, "leftOffsetPre");
+  baton->widthPre = sharp::AttrAsInt32(options, "widthPre");
+  baton->heightPre = sharp::AttrAsInt32(options, "heightPre");
+  baton->topOffsetPost = sharp::AttrAsInt32(options, "topOffsetPost");
+  baton->leftOffsetPost = sharp::AttrAsInt32(options, "leftOffsetPost");
+  baton->widthPost = sharp::AttrAsInt32(options, "widthPost");
+  baton->heightPost = sharp::AttrAsInt32(options, "heightPost");
   // Output image dimensions
-  baton->width = AttrTo<int32_t>(options, "width");
-  baton->height = AttrTo<int32_t>(options, "height");
+  baton->width = sharp::AttrAsInt32(options, "width");
+  baton->height = sharp::AttrAsInt32(options, "height");
   // Canvas option
-  std::string canvas = AttrAsStr(options, "canvas");
+  std::string canvas = sharp::AttrAsStr(options, "canvas");
   if (canvas == "crop") {
     baton->canvas = Canvas::CROP;
   } else if (canvas == "embed") {
@@ -1212,191 +1178,168 @@ NAN_METHOD(pipeline) {
     baton->canvas = Canvas::IGNORE_ASPECT;
   }
   // Tint chroma
-  baton->tintA = AttrTo<double>(options, "tintA");
-  baton->tintB = AttrTo<double>(options, "tintB");
+  baton->tintA = sharp::AttrAsDouble(options, "tintA");
+  baton->tintB = sharp::AttrAsDouble(options, "tintB");
   // Composite
-  v8::Local<v8::Array> compositeArray = Nan::Get(options, Nan::New("composite").ToLocalChecked())
-    .ToLocalChecked().As<v8::Array>();
-  int const compositeArrayLength = AttrTo<uint32_t>(compositeArray, "length");
-  for (int i = 0; i < compositeArrayLength; i++) {
-    v8::Local<v8::Object> compositeObject = Nan::Get(compositeArray, i).ToLocalChecked().As<v8::Object>();
+  Napi::Array compositeArray = options.Get("composite").As<Napi::Array>();
+  for (unsigned int i = 0; i < compositeArray.Length(); i++) {
+    Napi::Object compositeObject = compositeArray.Get(i).As<Napi::Object>();
     Composite *composite = new Composite;
-    composite->input = CreateInputDescriptor(AttrAs<v8::Object>(compositeObject, "input"), buffersToPersist);
+    composite->input = sharp::CreateInputDescriptor(compositeObject.Get("input").As<Napi::Object>());
     composite->mode = static_cast<VipsBlendMode>(
-      vips_enum_from_nick(nullptr, VIPS_TYPE_BLEND_MODE, AttrAsStr(compositeObject, "blend").data()));
-    composite->gravity = AttrTo<uint32_t>(compositeObject, "gravity");
-    composite->left = AttrTo<int32_t>(compositeObject, "left");
-    composite->top = AttrTo<int32_t>(compositeObject, "top");
-    composite->tile = AttrTo<bool>(compositeObject, "tile");
-    composite->premultiplied = AttrTo<bool>(compositeObject, "premultiplied");
+      vips_enum_from_nick(nullptr, VIPS_TYPE_BLEND_MODE, sharp::AttrAsStr(compositeObject, "blend").data()));
+    composite->gravity = sharp::AttrAsUint32(compositeObject, "gravity");
+    composite->left = sharp::AttrAsInt32(compositeObject, "left");
+    composite->top = sharp::AttrAsInt32(compositeObject, "top");
+    composite->tile = sharp::AttrAsBool(compositeObject, "tile");
+    composite->premultiplied = sharp::AttrAsBool(compositeObject, "premultiplied");
     baton->composite.push_back(composite);
   }
   // Resize options
-  baton->withoutEnlargement = AttrTo<bool>(options, "withoutEnlargement");
-  baton->position = AttrTo<int32_t>(options, "position");
-  baton->resizeBackground = AttrAsRgba(options, "resizeBackground");
-  baton->kernel = AttrAsStr(options, "kernel");
-  baton->fastShrinkOnLoad = AttrTo<bool>(options, "fastShrinkOnLoad");
+  baton->withoutEnlargement = sharp::AttrAsBool(options, "withoutEnlargement");
+  baton->position = sharp::AttrAsInt32(options, "position");
+  baton->resizeBackground = sharp::AttrAsRgba(options, "resizeBackground");
+  baton->kernel = sharp::AttrAsStr(options, "kernel");
+  baton->fastShrinkOnLoad = sharp::AttrAsBool(options, "fastShrinkOnLoad");
   // Join Channel Options
-  if (HasAttr(options, "joinChannelIn")) {
-    v8::Local<v8::Object> joinChannelObject = Nan::Get(options, Nan::New("joinChannelIn").ToLocalChecked())
-      .ToLocalChecked().As<v8::Object>();
-    v8::Local<v8::Array> joinChannelArray = joinChannelObject.As<v8::Array>();
-    int joinChannelArrayLength = AttrTo<int32_t>(joinChannelObject, "length");
-    for (int i = 0; i < joinChannelArrayLength; i++) {
+  if (options.Has("joinChannelIn")) {
+    Napi::Array joinChannelArray = options.Get("joinChannelIn").As<Napi::Array>();
+    for (unsigned int i = 0; i < joinChannelArray.Length(); i++) {
       baton->joinChannelIn.push_back(
-        CreateInputDescriptor(
-          Nan::Get(joinChannelArray, i).ToLocalChecked().As<v8::Object>(),
-          buffersToPersist));
+        sharp::CreateInputDescriptor(joinChannelArray.Get(i).As<Napi::Object>()));
     }
   }
   // Operators
-  baton->flatten = AttrTo<bool>(options, "flatten");
-  baton->flattenBackground = AttrAsRgba(options, "flattenBackground");
-  baton->negate = AttrTo<bool>(options, "negate");
-  baton->blurSigma = AttrTo<double>(options, "blurSigma");
-  baton->brightness = AttrTo<double>(options, "brightness");
-  baton->saturation = AttrTo<double>(options, "saturation");
-  baton->hue = AttrTo<int32_t>(options, "hue");
-  baton->medianSize = AttrTo<uint32_t>(options, "medianSize");
-  baton->sharpenSigma = AttrTo<double>(options, "sharpenSigma");
-  baton->sharpenFlat = AttrTo<double>(options, "sharpenFlat");
-  baton->sharpenJagged = AttrTo<double>(options, "sharpenJagged");
-  baton->threshold = AttrTo<int32_t>(options, "threshold");
-  baton->thresholdGrayscale = AttrTo<bool>(options, "thresholdGrayscale");
-  baton->trimThreshold = AttrTo<double>(options, "trimThreshold");
-  baton->gamma = AttrTo<double>(options, "gamma");
-  baton->gammaOut = AttrTo<double>(options, "gammaOut");
-  baton->linearA = AttrTo<double>(options, "linearA");
-  baton->linearB = AttrTo<double>(options, "linearB");
-  baton->greyscale = AttrTo<bool>(options, "greyscale");
-  baton->normalise = AttrTo<bool>(options, "normalise");
-  baton->useExifOrientation = AttrTo<bool>(options, "useExifOrientation");
-  baton->angle = AttrTo<int32_t>(options, "angle");
-  baton->rotationAngle = AttrTo<double>(options, "rotationAngle");
-  baton->rotationBackground = AttrAsRgba(options, "rotationBackground");
-  baton->rotateBeforePreExtract = AttrTo<bool>(options, "rotateBeforePreExtract");
-  baton->flip = AttrTo<bool>(options, "flip");
-  baton->flop = AttrTo<bool>(options, "flop");
-  baton->extendTop = AttrTo<int32_t>(options, "extendTop");
-  baton->extendBottom = AttrTo<int32_t>(options, "extendBottom");
-  baton->extendLeft = AttrTo<int32_t>(options, "extendLeft");
-  baton->extendRight = AttrTo<int32_t>(options, "extendRight");
-  baton->extendBackground = AttrAsRgba(options, "extendBackground");
-  baton->extractChannel = AttrTo<int32_t>(options, "extractChannel");
+  baton->flatten = sharp::AttrAsBool(options, "flatten");
+  baton->flattenBackground = sharp::AttrAsRgba(options, "flattenBackground");
+  baton->negate = sharp::AttrAsBool(options, "negate");
+  baton->blurSigma = sharp::AttrAsDouble(options, "blurSigma");
+  baton->brightness = sharp::AttrAsDouble(options, "brightness");
+  baton->saturation = sharp::AttrAsDouble(options, "saturation");
+  baton->hue = sharp::AttrAsInt32(options, "hue");
+  baton->medianSize = sharp::AttrAsUint32(options, "medianSize");
+  baton->sharpenSigma = sharp::AttrAsDouble(options, "sharpenSigma");
+  baton->sharpenFlat = sharp::AttrAsDouble(options, "sharpenFlat");
+  baton->sharpenJagged = sharp::AttrAsDouble(options, "sharpenJagged");
+  baton->threshold = sharp::AttrAsInt32(options, "threshold");
+  baton->thresholdGrayscale = sharp::AttrAsBool(options, "thresholdGrayscale");
+  baton->trimThreshold = sharp::AttrAsDouble(options, "trimThreshold");
+  baton->gamma = sharp::AttrAsDouble(options, "gamma");
+  baton->gammaOut = sharp::AttrAsDouble(options, "gammaOut");
+  baton->linearA = sharp::AttrAsDouble(options, "linearA");
+  baton->linearB = sharp::AttrAsDouble(options, "linearB");
+  baton->greyscale = sharp::AttrAsBool(options, "greyscale");
+  baton->normalise = sharp::AttrAsBool(options, "normalise");
+  baton->useExifOrientation = sharp::AttrAsBool(options, "useExifOrientation");
+  baton->angle = sharp::AttrAsInt32(options, "angle");
+  baton->rotationAngle = sharp::AttrAsDouble(options, "rotationAngle");
+  baton->rotationBackground = sharp::AttrAsRgba(options, "rotationBackground");
+  baton->rotateBeforePreExtract = sharp::AttrAsBool(options, "rotateBeforePreExtract");
+  baton->flip = sharp::AttrAsBool(options, "flip");
+  baton->flop = sharp::AttrAsBool(options, "flop");
+  baton->extendTop = sharp::AttrAsInt32(options, "extendTop");
+  baton->extendBottom = sharp::AttrAsInt32(options, "extendBottom");
+  baton->extendLeft = sharp::AttrAsInt32(options, "extendLeft");
+  baton->extendRight = sharp::AttrAsInt32(options, "extendRight");
+  baton->extendBackground = sharp::AttrAsRgba(options, "extendBackground");
+  baton->extractChannel = sharp::AttrAsInt32(options, "extractChannel");
 
-  baton->removeAlpha = AttrTo<bool>(options, "removeAlpha");
-  baton->ensureAlpha = AttrTo<bool>(options, "ensureAlpha");
-  if (HasAttr(options, "boolean")) {
-    baton->boolean = CreateInputDescriptor(AttrAs<v8::Object>(options, "boolean"), buffersToPersist);
-    baton->booleanOp = sharp::GetBooleanOperation(AttrAsStr(options, "booleanOp"));
+  baton->removeAlpha = sharp::AttrAsBool(options, "removeAlpha");
+  baton->ensureAlpha = sharp::AttrAsBool(options, "ensureAlpha");
+  if (options.Has("boolean")) {
+    baton->boolean = sharp::CreateInputDescriptor(options.Get("boolean").As<Napi::Object>());
+    baton->booleanOp = sharp::GetBooleanOperation(sharp::AttrAsStr(options, "booleanOp"));
   }
-  if (HasAttr(options, "bandBoolOp")) {
-    baton->bandBoolOp = sharp::GetBooleanOperation(AttrAsStr(options, "bandBoolOp"));
+  if (options.Has("bandBoolOp")) {
+    baton->bandBoolOp = sharp::GetBooleanOperation(sharp::AttrAsStr(options, "bandBoolOp"));
   }
-  if (HasAttr(options, "convKernel")) {
-    v8::Local<v8::Object> kernel = AttrAs<v8::Object>(options, "convKernel");
-    baton->convKernelWidth = AttrTo<uint32_t>(kernel, "width");
-    baton->convKernelHeight = AttrTo<uint32_t>(kernel, "height");
-    baton->convKernelScale = AttrTo<double>(kernel, "scale");
-    baton->convKernelOffset = AttrTo<double>(kernel, "offset");
+  if (options.Has("convKernel")) {
+    Napi::Object kernel = options.Get("convKernel").As<Napi::Object>();
+    baton->convKernelWidth = sharp::AttrAsUint32(kernel, "width");
+    baton->convKernelHeight = sharp::AttrAsUint32(kernel, "height");
+    baton->convKernelScale = sharp::AttrAsDouble(kernel, "scale");
+    baton->convKernelOffset = sharp::AttrAsDouble(kernel, "offset");
     size_t const kernelSize = static_cast<size_t>(baton->convKernelWidth * baton->convKernelHeight);
     baton->convKernel = std::unique_ptr<double[]>(new double[kernelSize]);
-    v8::Local<v8::Array> kdata = AttrAs<v8::Array>(kernel, "kernel");
+    Napi::Array kdata = kernel.Get("kernel").As<Napi::Array>();
     for (unsigned int i = 0; i < kernelSize; i++) {
-      baton->convKernel[i] = AttrTo<double>(kdata, i);
+      baton->convKernel[i] = sharp::AttrAsDouble(kdata, i);
     }
   }
-  if (HasAttr(options, "recombMatrix")) {
+  if (options.Has("recombMatrix")) {
     baton->recombMatrix = std::unique_ptr<double[]>(new double[9]);
-    v8::Local<v8::Array> recombMatrix = AttrAs<v8::Array>(options, "recombMatrix");
+    Napi::Array recombMatrix = options.Get("recombMatrix").As<Napi::Array>();
     for (unsigned int i = 0; i < 9; i++) {
-       baton->recombMatrix[i] = AttrTo<double>(recombMatrix, i);
+       baton->recombMatrix[i] = sharp::AttrAsDouble(recombMatrix, i);
     }
   }
-  baton->colourspace = sharp::GetInterpretation(AttrAsStr(options, "colourspace"));
+  baton->colourspace = sharp::GetInterpretation(sharp::AttrAsStr(options, "colourspace"));
   if (baton->colourspace == VIPS_INTERPRETATION_ERROR) {
     baton->colourspace = VIPS_INTERPRETATION_sRGB;
   }
   // Output
-  baton->formatOut = AttrAsStr(options, "formatOut");
-  baton->fileOut = AttrAsStr(options, "fileOut");
-  baton->withMetadata = AttrTo<bool>(options, "withMetadata");
-  baton->withMetadataOrientation = AttrTo<uint32_t>(options, "withMetadataOrientation");
+  baton->formatOut = sharp::AttrAsStr(options, "formatOut");
+  baton->fileOut = sharp::AttrAsStr(options, "fileOut");
+  baton->withMetadata = sharp::AttrAsBool(options, "withMetadata");
+  baton->withMetadataOrientation = sharp::AttrAsUint32(options, "withMetadataOrientation");
   // Format-specific
-  baton->jpegQuality = AttrTo<uint32_t>(options, "jpegQuality");
-  baton->jpegProgressive = AttrTo<bool>(options, "jpegProgressive");
-  baton->jpegChromaSubsampling = AttrAsStr(options, "jpegChromaSubsampling");
-  baton->jpegTrellisQuantisation = AttrTo<bool>(options, "jpegTrellisQuantisation");
-  baton->jpegQuantisationTable = AttrTo<uint32_t>(options, "jpegQuantisationTable");
-  baton->jpegOvershootDeringing = AttrTo<bool>(options, "jpegOvershootDeringing");
-  baton->jpegOptimiseScans = AttrTo<bool>(options, "jpegOptimiseScans");
-  baton->jpegOptimiseCoding = AttrTo<bool>(options, "jpegOptimiseCoding");
-  baton->pngProgressive = AttrTo<bool>(options, "pngProgressive");
-  baton->pngCompressionLevel = AttrTo<uint32_t>(options, "pngCompressionLevel");
-  baton->pngAdaptiveFiltering = AttrTo<bool>(options, "pngAdaptiveFiltering");
-  baton->pngPalette = AttrTo<bool>(options, "pngPalette");
-  baton->pngQuality = AttrTo<uint32_t>(options, "pngQuality");
-  baton->pngColours = AttrTo<uint32_t>(options, "pngColours");
-  baton->pngDither = AttrTo<double>(options, "pngDither");
-  baton->webpQuality = AttrTo<uint32_t>(options, "webpQuality");
-  baton->webpAlphaQuality = AttrTo<uint32_t>(options, "webpAlphaQuality");
-  baton->webpLossless = AttrTo<bool>(options, "webpLossless");
-  baton->webpNearLossless = AttrTo<bool>(options, "webpNearLossless");
-  baton->webpSmartSubsample = AttrTo<bool>(options, "webpSmartSubsample");
-  baton->webpReductionEffort = AttrTo<uint32_t>(options, "webpReductionEffort");
-  baton->tiffQuality = AttrTo<uint32_t>(options, "tiffQuality");
-  baton->tiffPyramid = AttrTo<bool>(options, "tiffPyramid");
-  baton->tiffSquash = AttrTo<bool>(options, "tiffSquash");
-  baton->tiffTile = AttrTo<bool>(options, "tiffTile");
-  baton->tiffTileWidth = AttrTo<uint32_t>(options, "tiffTileWidth");
-  baton->tiffTileHeight = AttrTo<uint32_t>(options, "tiffTileHeight");
-  baton->tiffXres = AttrTo<double>(options, "tiffXres");
-  baton->tiffYres = AttrTo<double>(options, "tiffYres");
+  baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
+  baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");
+  baton->jpegChromaSubsampling = sharp::AttrAsStr(options, "jpegChromaSubsampling");
+  baton->jpegTrellisQuantisation = sharp::AttrAsBool(options, "jpegTrellisQuantisation");
+  baton->jpegQuantisationTable = sharp::AttrAsUint32(options, "jpegQuantisationTable");
+  baton->jpegOvershootDeringing = sharp::AttrAsBool(options, "jpegOvershootDeringing");
+  baton->jpegOptimiseScans = sharp::AttrAsBool(options, "jpegOptimiseScans");
+  baton->jpegOptimiseCoding = sharp::AttrAsBool(options, "jpegOptimiseCoding");
+  baton->pngProgressive = sharp::AttrAsBool(options, "pngProgressive");
+  baton->pngCompressionLevel = sharp::AttrAsUint32(options, "pngCompressionLevel");
+  baton->pngAdaptiveFiltering = sharp::AttrAsBool(options, "pngAdaptiveFiltering");
+  baton->pngPalette = sharp::AttrAsBool(options, "pngPalette");
+  baton->pngQuality = sharp::AttrAsUint32(options, "pngQuality");
+  baton->pngColours = sharp::AttrAsUint32(options, "pngColours");
+  baton->pngDither = sharp::AttrAsDouble(options, "pngDither");
+  baton->webpQuality = sharp::AttrAsUint32(options, "webpQuality");
+  baton->webpAlphaQuality = sharp::AttrAsUint32(options, "webpAlphaQuality");
+  baton->webpLossless = sharp::AttrAsBool(options, "webpLossless");
+  baton->webpNearLossless = sharp::AttrAsBool(options, "webpNearLossless");
+  baton->webpSmartSubsample = sharp::AttrAsBool(options, "webpSmartSubsample");
+  baton->webpReductionEffort = sharp::AttrAsUint32(options, "webpReductionEffort");
+  baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
+  baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
+  baton->tiffSquash = sharp::AttrAsBool(options, "tiffSquash");
+  baton->tiffTile = sharp::AttrAsBool(options, "tiffTile");
+  baton->tiffTileWidth = sharp::AttrAsUint32(options, "tiffTileWidth");
+  baton->tiffTileHeight = sharp::AttrAsUint32(options, "tiffTileHeight");
+  baton->tiffXres = sharp::AttrAsDouble(options, "tiffXres");
+  baton->tiffYres = sharp::AttrAsDouble(options, "tiffYres");
   // tiff compression options
   baton->tiffCompression = static_cast<VipsForeignTiffCompression>(
   vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_COMPRESSION,
-    AttrAsStr(options, "tiffCompression").data()));
+    sharp::AttrAsStr(options, "tiffCompression").data()));
   baton->tiffPredictor = static_cast<VipsForeignTiffPredictor>(
   vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_PREDICTOR,
-    AttrAsStr(options, "tiffPredictor").data()));
-  baton->heifQuality = AttrTo<uint32_t>(options, "heifQuality");
-  baton->heifLossless = AttrTo<bool>(options, "heifLossless");
+    sharp::AttrAsStr(options, "tiffPredictor").data()));
+  baton->heifQuality = sharp::AttrAsUint32(options, "heifQuality");
+  baton->heifLossless = sharp::AttrAsBool(options, "heifLossless");
   baton->heifCompression = static_cast<VipsForeignHeifCompression>(
-  vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_HEIF_COMPRESSION,
-    AttrAsStr(options, "heifCompression").data()));
+    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_HEIF_COMPRESSION,
+    sharp::AttrAsStr(options, "heifCompression").data()));
   // Tile output
-  baton->tileSize = AttrTo<uint32_t>(options, "tileSize");
-  baton->tileOverlap = AttrTo<uint32_t>(options, "tileOverlap");
-  std::string tileContainer = AttrAsStr(options, "tileContainer");
-  baton->tileAngle = AttrTo<int32_t>(options, "tileAngle");
-  baton->tileBackground = AttrAsRgba(options, "tileBackground");
-  baton->tileSkipBlanks = AttrTo<int32_t>(options, "tileSkipBlanks");
-  if (tileContainer == "zip") {
-    baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_ZIP;
-  } else {
-    baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_FS;
-  }
-  std::string tileLayout = AttrAsStr(options, "tileLayout");
-  if (tileLayout == "google") {
-    baton->tileLayout = VIPS_FOREIGN_DZ_LAYOUT_GOOGLE;
-  } else if (tileLayout == "zoomify") {
-    baton->tileLayout = VIPS_FOREIGN_DZ_LAYOUT_ZOOMIFY;
-  } else {
-    baton->tileLayout = VIPS_FOREIGN_DZ_LAYOUT_DZ;
-  }
-  baton->tileFormat = AttrAsStr(options, "tileFormat");
-  std::string tileDepth = AttrAsStr(options, "tileDepth");
-  if (tileDepth == "onetile") {
-    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONETILE;
-  } else if (tileDepth == "one") {
-    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONE;
-  } else if (tileDepth == "onepixel") {
-    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL;
-  } else {
-    // signal that we do not want to pass any value to dzSave
-    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_LAST;
-  }
+  baton->tileSize = sharp::AttrAsUint32(options, "tileSize");
+  baton->tileOverlap = sharp::AttrAsUint32(options, "tileOverlap");
+  baton->tileAngle = sharp::AttrAsInt32(options, "tileAngle");
+  baton->tileBackground = sharp::AttrAsRgba(options, "tileBackground");
+  baton->tileSkipBlanks = sharp::AttrAsInt32(options, "tileSkipBlanks");
+  baton->tileContainer = static_cast<VipsForeignDzContainer>(
+    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_CONTAINER,
+    sharp::AttrAsStr(options, "tileContainer").data()));
+  baton->tileLayout = static_cast<VipsForeignDzLayout>(
+    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_LAYOUT,
+    sharp::AttrAsStr(options, "tileLayout").data()));
+  baton->tileFormat = sharp::AttrAsStr(options, "tileFormat");
+  baton->tileDepth = static_cast<VipsForeignDzDepth>(
+    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_DEPTH,
+    sharp::AttrAsStr(options, "tileDepth").data()));
 
   // Force random access for certain operations
   if (baton->input->access == VIPS_ACCESS_SEQUENTIAL) {
@@ -1404,25 +1347,30 @@ NAN_METHOD(pipeline) {
       baton->trimThreshold > 0.0 ||
       baton->normalise ||
       baton->position == 16 || baton->position == 17 ||
-      baton->angle != 0 || baton->rotationAngle != 0.0
+      baton->angle % 360 != 0 ||
+      fmod(baton->rotationAngle, 360.0) != 0.0 ||
+      baton->useExifOrientation
     ) {
       baton->input->access = VIPS_ACCESS_RANDOM;
     }
   }
 
   // Function to notify of libvips warnings
-  Nan::Callback *debuglog = new Nan::Callback(AttrAs<v8::Function>(options, "debuglog"));
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
 
   // Function to notify of queue length changes
-  Nan::Callback *queueListener = new Nan::Callback(AttrAs<v8::Function>(options, "queueListener"));
+  Napi::Function queueListener = options.Get("queueListener").As<Napi::Function>();
 
   // Join queue for worker thread
-  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
-  Nan::AsyncQueueWorker(new PipelineWorker(callback, baton, debuglog, queueListener, buffersToPersist));
+  Napi::Function callback = info[1].As<Napi::Function>();
+  PipelineWorker *worker = new PipelineWorker(callback, baton, debuglog, queueListener);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
 
   // Increment queued task counter
   g_atomic_int_inc(&sharp::counterQueue);
-  v8::Local<v8::Value> queueLength[1] = { Nan::New<v8::Uint32>(sharp::counterQueue) };
-  v8::Local<v8::Object> recv = Nan::New<v8::Object>();
-  Nan::Call(*queueListener, recv, 1, queueLength);
+  Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<double>(sharp::counterQueue));
+  queueListener.Call(info.This(), { queueLength });
+
+  return info.Env().Undefined();
 }

src/pipeline.h

@@ -19,12 +19,12 @@
 #include <string>
 #include <vector>
 
-#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,
@@ -150,7 +150,7 @@ struct PipelineBaton {
   double tiffXres;
   double tiffYres;
   int heifQuality;
-  int heifCompression;  // TODO(libvips 8.9.0): VipsForeignHeifCompression
+  VipsForeignHeifCompression heifCompression;
   bool heifLossless;
   std::string err;
   bool withMetadata;
@@ -258,7 +258,7 @@ struct PipelineBaton {
     tiffXres(1.0),
     tiffYres(1.0),
     heifQuality(80),
-    heifCompression(1),  // TODO(libvips 8.9.0): VIPS_FOREIGN_HEIF_COMPRESSION_HEVC
+    heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_HEVC),
     heifLossless(false),
     withMetadata(false),
     withMetadataOrientation(-1),

src/sharp.cc

@@ -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,30 @@
 #include "utilities.h"
 #include "stats.h"
 
-NAN_MODULE_INIT(init) {
+static void* sharp_vips_init(void*) {
   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("stats", Napi::Function::New(env, stats));
+  return exports;
 }
 
-NAN_MODULE_WORKER_ENABLED(sharp, init)
+NODE_API_MODULE(sharp, init)

src/stats.cc

@@ -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,13 +42,9 @@ 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);
     } catch (vips::VError const &err) {
@@ -71,25 +55,37 @@ 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
+        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();
       } catch (vips::VError const &err) {
         (baton->err).append(err.what());
       }
@@ -100,92 +96,79 @@ 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);
+      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->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

@@ -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) {}
 };
@@ -51,16 +47,18 @@ struct StatsBaton {
   std::vector<ChannelStats> channelStats;
   bool isOpaque;
   double entropy;
+  double sharpness;
 
   std::string err;
 
   StatsBaton():
     input(nullptr),
     isOpaque(true),
-    entropy(0.0)
+    entropy(0.0),
+    sharpness(0.0)
     {}
 };
 
-NAN_METHOD(stats);
+Napi::Value stats(const Napi::CallbackInfo& info);
 
 #endif  // SRC_STATS_H_

src/utilities.cc

@@ -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,59 @@ 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);
 }

src/utilities.h

@@ -15,14 +15,14 @@
 #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);
 
 #endif  // SRC_UTILITIES_H_

test/leak/sharp.supp

@@ -578,11 +578,14 @@
   fun:_ZN4node20BackgroundTaskRunnerC1Ei
 }
 {
-  leak_nan_FunctionCallbackInfo
+  leak_napi_module_register
   Memcheck:Leak
   match-leak-kinds: definite
   ...
-  fun:_ZN3Nan3impL23FunctionCallbackWrapperERKN2v820FunctionCallbackInfoINS1_5ValueEEE
+  fun:napi_module_register
+  fun:call_init.part.0
+  fun:call_init
+  fun:_dl_init
 }
 {
   leak_v8_FunctionCallbackInfo

test/unit/beforeEach.js

@@ -5,7 +5,10 @@ const sharp = require('../../');
 
 const usingCache = detectLibc.family !== detectLibc.MUSL;
 const usingSimd = !process.env.G_DEBUG;
-const concurrency = detectLibc.family === detectLibc.MUSL ? 1 : undefined;
+const concurrency =
+  detectLibc.family === detectLibc.MUSL || process.arch === 'arm'
+    ? 1
+    : undefined;
 
 beforeEach(function () {
   sharp.cache(usingCache);

test/unit/composite.js

@@ -141,7 +141,7 @@ describe('composite', () => {
 
   it('zero offset', done => {
     sharp(fixtures.inputJpg)
-      .resize(400)
+      .resize(80)
       .composite([{
         input: fixtures.inputPngWithTransparency16bit,
         top: 0,
@@ -157,7 +157,7 @@ describe('composite', () => {
 
   it('offset and gravity', done => {
     sharp(fixtures.inputJpg)
-      .resize(400)
+      .resize(80)
       .composite([{
         input: fixtures.inputPngWithTransparency16bit,
         left: 10,
@@ -174,7 +174,7 @@ describe('composite', () => {
 
   it('offset, gravity and tile', done => {
     sharp(fixtures.inputJpg)
-      .resize(400)
+      .resize(80)
       .composite([{
         input: fixtures.inputPngWithTransparency16bit,
         left: 10,
@@ -192,7 +192,7 @@ describe('composite', () => {
 
   it('offset and tile', done => {
     sharp(fixtures.inputJpg)
-      .resize(400)
+      .resize(80)
       .composite([{
         input: fixtures.inputPngWithTransparency16bit,
         left: 10,

test/unit/extractChannel.js

@@ -80,6 +80,19 @@ describe('Image channel extraction', function () {
       });
   });
 
+  it('Alpha from 2-channel input', function (done) {
+    const output = fixtures.path('output.extract-alpha-2-channel.png');
+    sharp(fixtures.inputPngWithGreyAlpha)
+      .extractChannel('alpha')
+      .toColourspace('b-w')
+      .toFile(output, function (err, info) {
+        if (err) throw err;
+        assert.strictEqual(1, info.channels);
+        fixtures.assertMaxColourDistance(output, fixtures.expected('extract-alpha-2-channel.png'));
+        done();
+      });
+  });
+
   it('Invalid channel number', function () {
     assert.throws(function () {
       sharp(fixtures.inputJpg)

test/unit/failOnError.js

@@ -19,11 +19,17 @@ describe('failOnError', function () {
       });
   });
 
-  it('handles truncated PNG', function (done) {
+  it('handles truncated PNG, emits warnings', function (done) {
+    let isWarningEmitted = false;
     sharp(fixtures.inputPngTruncated, { failOnError: false })
+      .on('warning', function (warning) {
+        assert.strictEqual('not enough data', warning);
+        isWarningEmitted = true;
+      })
       .resize(320, 240)
       .toBuffer(function (err, data, info) {
         if (err) throw err;
+        assert.strictEqual(true, isWarningEmitted);
         assert.strictEqual('png', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
@@ -48,8 +54,8 @@ describe('failOnError', function () {
   it('returns errors to callback for truncated JPEG', function (done) {
     sharp(fixtures.inputJpgTruncated).toBuffer(function (err, data, info) {
       assert.ok(err.message.includes('VipsJpeg: Premature end of JPEG file'), err);
-      assert.strictEqual(data, null);
-      assert.strictEqual(info, null);
+      assert.strictEqual(data, undefined);
+      assert.strictEqual(info, undefined);
       done();
     });
   });
@@ -57,8 +63,8 @@ describe('failOnError', function () {
   it('returns errors to callback for truncated PNG', function (done) {
     sharp(fixtures.inputPngTruncated).toBuffer(function (err, data, info) {
       assert.ok(err.message.includes('vipspng: libpng read error'), err);
-      assert.strictEqual(data, null);
-      assert.strictEqual(info, null);
+      assert.strictEqual(data, undefined);
+      assert.strictEqual(info, undefined);
       done();
     });
   });

test/unit/io.js

@@ -234,22 +234,6 @@ describe('Input/output', function () {
       })
   );
 
-  it('Sequential read, force JPEG - deprecated', function (done) {
-    sharp(fixtures.inputJpg)
-      .sequentialRead()
-      .resize(320, 240)
-      .toFormat(sharp.format.jpeg)
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual(data.length, info.size);
-        assert.strictEqual('jpeg', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        done();
-      });
-  });
-
   it('Not sequential read, force JPEG', () =>
     sharp(fixtures.inputJpg, { sequentialRead: false })
       .resize(320, 240)
@@ -264,22 +248,6 @@ describe('Input/output', function () {
       })
   );
 
-  it('Not sequential read, force JPEG - deprecated', function (done) {
-    sharp(fixtures.inputJpg)
-      .sequentialRead(false)
-      .resize(320, 240)
-      .toFormat('jpeg')
-      .toBuffer(function (err, data, info) {
-        if (err) throw err;
-        assert.strictEqual(true, data.length > 0);
-        assert.strictEqual(data.length, info.size);
-        assert.strictEqual('jpeg', info.format);
-        assert.strictEqual(320, info.width);
-        assert.strictEqual(240, info.height);
-        done();
-      });
-  });
-
   it('Support output to jpg format', function (done) {
     sharp(fixtures.inputPng)
       .resize(320, 240)
@@ -334,6 +302,7 @@ describe('Input/output', function () {
   });
 
   it('Fail when input is empty Buffer', function (done) {
+    if (sharp.format.magick.input.buffer) return this.skip(); // can be removed with libvips 8.10.0+
     sharp(Buffer.alloc(0)).toBuffer().then(function () {
       assert(false);
       done();
@@ -653,81 +622,6 @@ describe('Input/output', function () {
     );
   });
 
-  describe('Limit pixel count of input image - deprecated', function () {
-    it('Invalid fails - negative', function (done) {
-      let isValid = false;
-      try {
-        sharp().limitInputPixels(-1);
-        isValid = true;
-      } catch (e) {}
-      assert(!isValid);
-      done();
-    });
-
-    it('Invalid fails - float', function (done) {
-      let isValid = false;
-      try {
-        sharp().limitInputPixels(12.3);
-        isValid = true;
-      } catch (e) {}
-      assert(!isValid);
-      done();
-    });
-
-    it('Invalid fails - string', function (done) {
-      let isValid = false;
-      try {
-        sharp().limitInputPixels('fail');
-        isValid = true;
-      } catch (e) {}
-      assert(!isValid);
-      done();
-    });
-
-    it('Same size as input works', function (done) {
-      sharp(fixtures.inputJpg).metadata(function (err, metadata) {
-        if (err) throw err;
-        sharp(fixtures.inputJpg)
-          .limitInputPixels(metadata.width * metadata.height)
-          .toBuffer(function (err) {
-            assert.strictEqual(true, !err);
-            done();
-          });
-      });
-    });
-
-    it('Disabling limit works', function (done) {
-      sharp(fixtures.inputJpgLarge)
-        .limitInputPixels(false)
-        .resize(2)
-        .toBuffer(function (err) {
-          assert.strictEqual(true, !err);
-          done();
-        });
-    });
-
-    it('Enabling default limit works and fails with a large image', function (done) {
-      sharp(fixtures.inputJpgLarge)
-        .limitInputPixels(true)
-        .toBuffer(function (err) {
-          assert.strictEqual(true, !!err);
-          done();
-        });
-    });
-
-    it('Smaller than input fails', function (done) {
-      sharp(fixtures.inputJpg).metadata(function (err, metadata) {
-        if (err) throw err;
-        sharp(fixtures.inputJpg)
-          .limitInputPixels((metadata.width * metadata.height) - 1)
-          .toBuffer(function (err) {
-            assert.strictEqual(true, !!err);
-            done();
-          });
-      });
-    });
-  });
-
   describe('Input options', function () {
     it('Option-less', function () {
       sharp();
@@ -765,6 +659,19 @@ describe('Input/output', function () {
         sharp({ pages: '1' });
       }, /Expected integer between -1 and 100000 for pages but received 1 of type string/);
     });
+    it('Valid level property', function () {
+      sharp({ level: 1 });
+    });
+    it('Invalid level property (string) throws', function () {
+      assert.throws(function () {
+        sharp({ level: '1' });
+      }, /Expected integer between 0 and 256 for level but received 1 of type string/);
+    });
+    it('Invalid level property (negative) throws', function () {
+      assert.throws(function () {
+        sharp({ level: -1 });
+      }, /Expected integer between 0 and 256 for level but received -1 of type number/);
+    });
   });
 
   describe('create new image', function () {

test/unit/metadata.js

@@ -19,7 +19,7 @@ describe('Image metadata', function () {
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
-      assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual(true, ['undefined', 'number'].includes(typeof metadata.density));
       assert.strictEqual('4:2:0', metadata.chromaSubsampling);
       assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
@@ -311,7 +311,7 @@ describe('Image metadata', function () {
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
-      assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual(true, ['undefined', 'number'].includes(typeof metadata.density));
       assert.strictEqual('4:2:0', metadata.chromaSubsampling);
       assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
@@ -343,7 +343,7 @@ describe('Image metadata', function () {
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
-      assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual(true, ['undefined', 'number'].includes(typeof metadata.density));
       assert.strictEqual('4:2:0', metadata.chromaSubsampling);
       assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
@@ -381,7 +381,7 @@ describe('Image metadata', function () {
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
-      assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual(true, ['undefined', 'number'].includes(typeof metadata.density));
       assert.strictEqual('4:2:0', metadata.chromaSubsampling);
       assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);
@@ -405,7 +405,7 @@ describe('Image metadata', function () {
       assert.strictEqual('srgb', metadata.space);
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual('uchar', metadata.depth);
-      assert.strictEqual('undefined', typeof metadata.density);
+      assert.strictEqual(true, ['undefined', 'number'].includes(typeof metadata.density));
       assert.strictEqual('4:2:0', metadata.chromaSubsampling);
       assert.strictEqual(false, metadata.isProgressive);
       assert.strictEqual(false, metadata.hasProfile);

test/unit/platform.js

@@ -43,7 +43,10 @@ describe('Platform-detection', function () {
 
   it('Defaults to ARMv6 for 32-bit', function () {
     process.env.npm_config_arch = 'arm';
+    const armVersion = process.config.variables.arm_version;
+    delete process.config.variables.arm_version;
     assert.strictEqual('armv6', platform().split('-')[1]);
+    process.config.variables.arm_version = armVersion;
     delete process.env.npm_config_arch;
   });
 

test/unit/png.js

@@ -127,8 +127,8 @@ describe('PNG', function () {
   it('Valid PNG libimagequant quality value produces image of same size or smaller', function () {
     const inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     return Promise.all([
-      sharp(inputPngBuffer).resize(10).png({ palette: true, quality: 80 }).toBuffer(),
-      sharp(inputPngBuffer).resize(10).png({ palette: true, quality: 100 }).toBuffer()
+      sharp(inputPngBuffer).resize(10).png({ quality: 80 }).toBuffer(),
+      sharp(inputPngBuffer).resize(10).png({ quality: 100 }).toBuffer()
     ]).then(function (data) {
       assert.strictEqual(true, data[0].length <= data[1].length);
     });
@@ -136,15 +136,15 @@ describe('PNG', function () {
 
   it('Invalid PNG libimagequant quality value throws error', function () {
     assert.throws(function () {
-      sharp().png({ palette: true, quality: 101 });
+      sharp().png({ quality: 101 });
     });
   });
 
   it('Valid PNG libimagequant colours value produces image of same size or smaller', function () {
     const inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     return Promise.all([
-      sharp(inputPngBuffer).resize(10).png({ palette: true, colours: 100 }).toBuffer(),
-      sharp(inputPngBuffer).resize(10).png({ palette: true, colours: 200 }).toBuffer()
+      sharp(inputPngBuffer).resize(10).png({ colours: 100 }).toBuffer(),
+      sharp(inputPngBuffer).resize(10).png({ colours: 200 }).toBuffer()
     ]).then(function (data) {
       assert.strictEqual(true, data[0].length <= data[1].length);
     });
@@ -152,21 +152,21 @@ describe('PNG', function () {
 
   it('Invalid PNG libimagequant colours value throws error', function () {
     assert.throws(function () {
-      sharp().png({ palette: true, colours: -1 });
+      sharp().png({ colours: -1 });
     });
   });
 
   it('Invalid PNG libimagequant colors value throws error', function () {
     assert.throws(function () {
-      sharp().png({ palette: true, colors: 0.1 });
+      sharp().png({ colors: 0.1 });
     });
   });
 
   it('Valid PNG libimagequant dither value produces image of same size or smaller', function () {
     const inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     return Promise.all([
-      sharp(inputPngBuffer).resize(10).png({ palette: true, dither: 0.1 }).toBuffer(),
-      sharp(inputPngBuffer).resize(10).png({ palette: true, dither: 0.9 }).toBuffer()
+      sharp(inputPngBuffer).resize(10).png({ dither: 0.1 }).toBuffer(),
+      sharp(inputPngBuffer).resize(10).png({ dither: 0.9 }).toBuffer()
     ]).then(function (data) {
       assert.strictEqual(true, data[0].length <= data[1].length);
     });
@@ -174,7 +174,7 @@ describe('PNG', function () {
 
   it('Invalid PNG libimagequant dither value throws error', function () {
     assert.throws(function () {
-      sharp().png({ palette: true, dither: 'fail' });
+      sharp().png({ dither: 'fail' });
     });
   });
 });

test/unit/raw.js

@@ -168,5 +168,19 @@ describe('Raw pixel data', function () {
           done();
         });
     });
+
+    it('extract A from RGBA', () =>
+      sharp(fixtures.inputPngWithTransparency)
+        .resize(32, 24)
+        .extractChannel(3)
+        .toColourspace('b-w')
+        .raw()
+        .toBuffer({ resolveWithObject: true })
+        .then(({ info }) => {
+          assert.strictEqual('raw', info.format);
+          assert.strictEqual(1, info.channels);
+          assert.strictEqual(32 * 24, info.size);
+        })
+    );
   });
 });

test/unit/stats.js

@@ -25,6 +25,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 7.319914765248541));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 0.7883011147075762));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -84,6 +85,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 0.3409031108021736));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 9.111356137722868));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -110,6 +112,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(false, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 0.06778064835816622));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 2.522916068931278));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -185,6 +188,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(false, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 0));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 0));
 
       // alpha channel
       assert.strictEqual(0, stats.channels[3].min);
@@ -212,6 +216,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 0.3851250782608986));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 10.312521863719589));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -239,6 +244,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 7.51758075132966));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 9.959951636662941));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -298,6 +304,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 6.087309412541799));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 2.9250574456255682));
 
       // red channel
       assert.strictEqual(35, stats.channels[0].min);
@@ -357,6 +364,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(false, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 1));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 15.870619016486861));
 
       // gray channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -410,6 +418,7 @@ describe('Image Stats', function () {
 
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 7.319914765248541));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 0.788301114707569));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -472,6 +481,7 @@ describe('Image Stats', function () {
     return pipeline.stats().then(function (stats) {
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 7.319914765248541));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 0.788301114707569));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -529,6 +539,7 @@ describe('Image Stats', function () {
     return sharp(fixtures.inputJpg).stats().then(function (stats) {
       assert.strictEqual(true, stats.isOpaque);
       assert.strictEqual(true, isInAcceptableRange(stats.entropy, 7.319914765248541));
+      assert.strictEqual(true, isInAcceptableRange(stats.sharpness, 0.788301114707569));
 
       // red channel
       assert.strictEqual(0, stats.channels[0].min);
@@ -582,6 +593,18 @@ describe('Image Stats', function () {
     });
   });
 
+  it('Blurred image has lower sharpness than original', () => {
+    const original = sharp(fixtures.inputJpg).stats();
+    const blurred = sharp(fixtures.inputJpg).blur().toBuffer().then(blur => sharp(blur).stats());
+
+    return Promise
+      .all([original, blurred])
+      .then(([original, blurred]) => {
+        assert.strictEqual(true, isInAcceptableRange(original.sharpness, 0.7883011147075476));
+        assert.strictEqual(true, isInAcceptableRange(blurred.sharpness, 0.4791559805997398));
+      });
+  });
+
   it('File input with corrupt header fails gracefully', function (done) {
     sharp(fixtures.inputJpgWithCorruptHeader)
       .stats(function (err) {

test/unit/tiff.js

@@ -208,11 +208,48 @@ describe('TIFF', function () {
       .toFile(fixtures.outputTiff, (err, info) => {
         if (err) throw err;
         assert.strictEqual('tiff', info.format);
+        assert.strictEqual(3, info.channels);
         assert(info.size < startSize);
         rimraf(fixtures.outputTiff, done);
       });
   });
 
+  it('TIFF LZW RGBA toFile', () =>
+    sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 4,
+        background: 'red'
+      }
+    })
+      .tiff({
+        compression: 'lzw'
+      })
+      .toFile(fixtures.outputTiff)
+      .then(info => {
+        assert.strictEqual(4, info.channels);
+      })
+  );
+
+  it('TIFF LZW RGBA toBuffer', () =>
+    sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 4,
+        background: 'red'
+      }
+    })
+      .tiff({
+        compression: 'lzw'
+      })
+      .toBuffer({ resolveWithObject: true })
+      .then(({ info }) => {
+        assert.strictEqual(4, info.channels);
+      })
+  );
+
   it('TIFF ccittfax4 compression shrinks b-w test file', function (done) {
     const startSize = fs.statSync(fixtures.inputTiff).size;
     sharp(fixtures.inputTiff)

test/unit/tile.js

@@ -765,6 +765,30 @@ describe('Tile', function () {
     });
   });
 
+  it('IIIF layout', function (done) {
+    const directory = fixtures.path('output.iiif.info');
+    rimraf(directory, function () {
+      sharp(fixtures.inputJpg)
+        .tile({
+          layout: 'iiif'
+        })
+        .toFile(directory, function (err, info) {
+          if (err) throw err;
+          assert.strictEqual('dz', info.format);
+          assert.strictEqual(2725, info.width);
+          assert.strictEqual(2225, info.height);
+          assert.strictEqual(3, info.channels);
+          assert.strictEqual('number', typeof info.size);
+          fs.stat(path.join(directory, '0,0,256,256', '256,', '0', 'default.jpg'), function (err, stat) {
+            if (err) throw err;
+            assert.strictEqual(true, stat.isFile());
+            assert.strictEqual(true, stat.size > 0);
+            done();
+          });
+        });
+    });
+  });
+
   it('Write to ZIP container using file extension', function (done) {
     const container = fixtures.path('output.dz.container.zip');
     const extractTo = fixtures.path('output.dz.container');

test/unit/trim.js

@@ -94,6 +94,32 @@ describe('Trim borders', function () {
       .catch(done);
   });
 
+  it('should rotate before trim', () =>
+    sharp({
+      create: {
+        width: 20,
+        height: 30,
+        channels: 3,
+        background: 'white'
+      }
+    })
+      .rotate(30)
+      .png()
+      .toBuffer()
+      .then(rotated30 =>
+        sharp(rotated30)
+          .rotate(-30)
+          .trim(128)
+          .toBuffer({ resolveWithObject: true })
+          .then(({ info }) => {
+            assert.strictEqual(20, info.width);
+            assert.strictEqual(31, info.height);
+            assert.strictEqual(-8, info.trimOffsetTop);
+            assert.strictEqual(-13, info.trimOffsetLeft);
+          })
+      )
+  );
+
   describe('Invalid thresholds', function () {
     [-1, 'fail', {}].forEach(function (threshold) {
       it(JSON.stringify(threshold), function () {