Release v0.30.0

Co-authored-by: Lovell Fuller <github@lovell.info>

.circleci/config.yml

@@ -0,0 +1,79 @@
+version: 2.1
+
+workflows:
+  build:
+    jobs:
+      - linux-arm64-glibc-node-12:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-musl-node-12:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-glibc-node-16:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-musl-node-16:
+          filters:
+            tags:
+              only: /^v.*/
+
+jobs:
+  linux-arm64-glibc-node-12:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:202101-01
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp arm64v8/debian:bullseye
+          sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+          sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+          sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_12.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+          sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs"
+      - run: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      - run: sudo docker exec sharp sh -c "npm test"
+      - run: "[[ -n $CIRCLE_TAG ]] && sudo docker exec --env prebuild_upload sharp sh -c \"npx prebuild --runtime napi --target 5 --upload=$prebuild_upload\" || true"
+  linux-arm64-glibc-node-16:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:202101-01
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --workdir /mnt/sharp arm64v8/debian:bullseye
+          sudo docker exec sharp sh -c "apt-get update && apt-get install -y build-essential git python3 curl"
+          sudo docker exec sharp sh -c "curl -s https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -"
+          sudo docker exec sharp sh -c "echo 'deb https://deb.nodesource.com/node_16.x sid main' >/etc/apt/sources.list.d/nodesource.list"
+          sudo docker exec sharp sh -c "apt-get update && apt-get install -y nodejs"
+          sudo docker exec sharp sh -c "mkdir -p /mnt/sharp"
+          sudo docker cp . sharp:/mnt/sharp/.
+      - run: sudo docker exec sharp sh -c "npm install --build-from-source"
+      - run: sudo docker exec sharp sh -c "npm test"
+  linux-arm64-musl-node-12:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:202101-01
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:12-alpine3.11
+          sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+      - run: sudo docker exec sharp sh -c "npm install --build-from-source --unsafe-perm"
+      - run: sudo docker exec sharp sh -c "npm test"
+      - run: "[[ -n $CIRCLE_TAG ]] && sudo docker exec --env prebuild_upload sharp sh -c \"npx prebuild --runtime napi --target 5 --upload=$prebuild_upload\" || true"
+  linux-arm64-musl-node-16:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:202101-01
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --workdir /mnt/sharp node:16-alpine3.11
+          sudo docker exec sharp sh -c "apk add build-base git python3 --update-cache"
+          sudo docker exec sharp sh -c "mkdir -p /mnt/sharp"
+          sudo docker cp . sharp:/mnt/sharp/.
+      - run: sudo docker exec sharp sh -c "npm install --build-from-source"
+      - run: sudo docker exec sharp sh -c "npm test"

.cirrus.yml

@@ -5,6 +5,7 @@ task:
   name: FreeBSD 13.0
   env:
     IGNORE_OSVERSION: yes
+  skip_notifications: true
   prerequisites_script:
     - pkg update -f
     - pkg upgrade -y

.github/workflows/ci-darwin-arm64v8.yml

@@ -0,0 +1,36 @@
+name: CI (MacStadium)
+on:
+  - push
+  - pull_request
+jobs:
+  CI:
+    runs-on: macos-m1
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - nodejs_version: 12
+            nodejs_architecture: x64
+          - nodejs_version: 16
+            nodejs_architecture: arm64
+            prebuild: true
+    defaults:
+      run:
+        shell: /usr/bin/arch -arch arm64e /bin/bash -l {0}
+    steps:
+      - name: Dependencies
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.nodejs_version }}
+          architecture: ${{ matrix.nodejs_architecture }}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install
+        run: npm install --build-from-source --unsafe-perm
+      - name: Test
+        run: npm test
+      - name: Prebuild
+        if: matrix.prebuild && startsWith(github.ref, 'refs/tags/')
+        env:
+          prebuild_upload: ${{ secrets.GITHUB_TOKEN }}
+        run: npx prebuild --runtime napi --target 5

.github/workflows/ci.yml

@@ -1,3 +1,4 @@
+name: CI (GitHub)
 on:
   - push
   - pull_request
@@ -11,53 +12,46 @@ jobs:
         include:
           - os: ubuntu-20.04
             container: centos:7
-            nodejs_version: 10
+            nodejs_version: 12
             coverage: true
             prebuild: true
-          - os: ubuntu-20.04
-            container: centos:7
-            nodejs_version: 12
           - os: ubuntu-20.04
             container: centos:7
             nodejs_version: 14
           - os: ubuntu-20.04
             container: centos:7
-            nodejs_version: 15
-          - os: ubuntu-20.04
-            container: node:10-alpine3.11
-            prebuild: true
+            nodejs_version: 16
           - os: ubuntu-20.04
             container: node:12-alpine3.11
+            prebuild: true
           - os: ubuntu-20.04
             container: node:14-alpine3.11
           - os: ubuntu-20.04
             container: node:14-alpine3.13
           - os: ubuntu-20.04
-            container: node:15-alpine3.11
-          - os: macos-10.15
-            nodejs_version: 10
-            prebuild: true
+            container: node:16-alpine3.11
           - os: macos-10.15
             nodejs_version: 12
+            prebuild: true
           - os: macos-10.15
             nodejs_version: 14
           - os: macos-10.15
-            nodejs_version: 15
-          - os: windows-2019
-            nodejs_version: 10
-            prebuild: true
+            nodejs_version: 16
           - os: windows-2019
             nodejs_version: 12
+            prebuild: true
           - os: windows-2019
             nodejs_version: 14
           - os: windows-2019
-            nodejs_version: 15
+            nodejs_version: 16
     steps:
       - name: Dependencies (Linux glibc)
         if: contains(matrix.container, 'centos')
         run: |
           curl -sL https://rpm.nodesource.com/setup_${{ matrix.nodejs_version }}.x | bash -
-          yum install -y gcc-c++ make git python3 nodejs
+          yum install -y centos-release-scl
+          yum install -y devtoolset-10-gcc-c++ make git python3 nodejs
+          echo "/opt/rh/devtoolset-10/root/usr/bin" >> $GITHUB_PATH
       - name: Dependencies (Linux musl)
         if: contains(matrix.container, 'alpine')
         run: apk add build-base git python3 --update-cache
@@ -84,4 +78,4 @@ jobs:
         if: matrix.prebuild && startsWith(github.ref, 'refs/tags/')
         env:
           prebuild_upload: ${{ secrets.GITHUB_TOKEN }}
-        run: npx prebuild --runtime napi --target 3
+        run: npx prebuild --runtime napi --target 5

.prebuildrc

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

.travis.yml

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

README.md

@@ -4,7 +4,7 @@
 
 The typical use case for this high speed Node.js module
 is to convert large images in common formats to
-smaller, web-friendly JPEG, PNG, WebP and AVIF images of varying dimensions.
+smaller, web-friendly JPEG, PNG, WebP, GIF and AVIF images of varying dimensions.
 
 Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings
@@ -16,7 +16,7 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern macOS, Windows and Linux systems running Node.js v10+
+Most modern macOS, Windows and Linux systems running Node.js >= 12.13.0
 do not require any additional install or runtime dependencies.
 
 ## Documentation
@@ -99,11 +99,11 @@ A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/C
 covers reporting bugs, requesting features and submitting code changes.
 
 [![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)
+[![Node-API v5](https://img.shields.io/badge/Node--API-v5-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
 ## Licensing
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

appveyor.yml

@@ -4,15 +4,14 @@ build: off
 platform: x86
 environment:
   matrix:
-  - nodejs_version: "10"
-    prebuild: true
   - nodejs_version: "12"
+    prebuild: true
   - nodejs_version: "14"
-  - nodejs_version: "15"
+  - nodejs_version: "16"
 install:
   - ps: Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version)
   - npm install --build-from-source
 test_script:
   - npm test
 on_success:
-  - if [%prebuild%] == [true] if [%APPVEYOR_REPO_TAG%] == [true] npx prebuild --runtime napi --target 3
+  - if [%prebuild%] == [true] if [%APPVEYOR_REPO_TAG%] == [true] npx prebuild --runtime napi --target 5

binding.gyp

@@ -1,7 +1,8 @@
 {
   'variables': {
     'vips_version': '<!(node -p "require(\'./lib/libvips\').minimumLibvipsVersion")',
-    'sharp_vendor_dir': '<(module_root_dir)/vendor/<(vips_version)'
+    'platform_and_arch': '<!(node -p "require(\'./lib/platform\')()")',
+    'sharp_vendor_dir': './vendor/<(vips_version)/<(platform_and_arch)'
   },
   'targets': [{
     'target_name': 'libvips-cpp',
@@ -37,6 +38,8 @@
             'msvs_settings': {
               'VCCLCompilerTool': {
                 'ExceptionHandling': 1,
+                'Optimization': 1,
+                'RuntimeLibrary': '2', # /MD
                 'WholeProgramOptimization': 'true'
               },
               'VCLibrarianTool': {
@@ -65,9 +68,9 @@
       }]
     ]
   }, {
-    'target_name': 'sharp',
+    'target_name': 'sharp-<(platform_and_arch)',
     'defines': [
-      'NAPI_VERSION=3'
+      'NAPI_VERSION=5'
     ],
     'dependencies': [
       '<!(node -p "require(\'node-addon-api\').gyp")',
@@ -138,7 +141,7 @@
           }],
           ['OS == "mac"', {
             'link_settings': {
-              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
               'libraries': [
                 'libvips-cpp.42.dylib'
               ]
@@ -146,7 +149,7 @@
             'xcode_settings': {
               'OTHER_LDFLAGS': [
                 # Ensure runtime linking is relative to sharp.node
-                '-Wl,-rpath,\'@loader_path/../../vendor/<(vips_version)/lib\''
+                '-Wl,-rpath,\'@loader_path/../../<(sharp_vendor_dir)/lib\''
               ]
             }
           }],
@@ -155,13 +158,13 @@
               '_GLIBCXX_USE_CXX11_ABI=1'
             ],
             'link_settings': {
-              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
               'libraries': [
                 '-l:libvips-cpp.so.42'
               ],
               'ldflags': [
                 # Ensure runtime linking is relative to sharp.node
-                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../vendor/<(vips_version)/lib\''
+                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../<(sharp_vendor_dir)/lib\''
               ]
             }
           }]
@@ -172,7 +175,7 @@
       '-std=c++0x',
       '-fexceptions',
       '-Wall',
-      '-O3'
+      '-Os'
     ],
     'xcode_settings': {
       'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
@@ -182,7 +185,7 @@
       'OTHER_CPLUSPLUSFLAGS': [
         '-fexceptions',
         '-Wall',
-        '-O3'
+        '-Oz'
       ]
     },
     'configurations': {
@@ -202,6 +205,8 @@
             'msvs_settings': {
               'VCCLCompilerTool': {
                 'ExceptionHandling': 1,
+                'Optimization': 1,
+                'RuntimeLibrary': '2', # /MD
                 'WholeProgramOptimization': 'true'
               },
               'VCLibrarianTool': {

docs/README.md

@@ -4,7 +4,7 @@
 
 The typical use case for this high speed Node.js module
 is to convert large images in common formats to
-smaller, web-friendly JPEG, PNG, AVIF and WebP images of varying dimensions.
+smaller, web-friendly JPEG, PNG, WebP, GIF and AVIF images of varying dimensions.
 
 Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings
@@ -16,14 +16,14 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern macOS, Windows and Linux systems running Node.js v10+
+Most modern macOS, Windows and Linux systems running Node.js >= 12.13.0
 do not require any additional install or runtime dependencies.
 
 ### Formats
 
-This module supports reading JPEG, PNG, WebP, AVIF, TIFF, GIF and SVG images.
+This module supports reading JPEG, PNG, WebP, GIF, AVIF, TIFF and SVG images.
 
-Output images can be in JPEG, PNG, WebP, AVIF and TIFF formats as well as uncompressed raw pixel data.
+Output images can be in JPEG, PNG, WebP, GIF, AVIF and TIFF formats as well as uncompressed raw pixel data.
 
 Streams, Buffer objects and the filesystem can be used for input and output.
 
@@ -70,7 +70,7 @@ covers reporting bugs, requesting features and submitting code changes.
 
 ### Licensing
 
-Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

docs/api-channel.md

@@ -4,6 +4,8 @@
 
 Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
 
+See also [flatten][1].
+
 ### Examples
 
 ```javascript
@@ -18,23 +20,38 @@ Returns **Sharp**
 
 ## ensureAlpha
 
-Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+Ensure the output image has an alpha transparency channel.
+If missing, the added alpha channel will have the specified
+transparency level, defaulting to fully-opaque (1).
+This is a no-op if the image already has an alpha channel.
+
+### Parameters
+
+*   `alpha` **[number][2]** alpha transparency level (0=fully-transparent, 1=fully-opaque) (optional, default `1`)
 
 ### Examples
 
 ```javascript
-sharp('rgb.jpg')
+// rgba.png will be a 4 channel image with a fully-opaque alpha channel
+await sharp('rgb.jpg')
   .ensureAlpha()
-  .toFile('rgba.png', function(err, info) {
-    // rgba.png is a 4 channel image with a fully opaque alpha channel
-  });
+  .toFile('rgba.png')
 ```
 
+```javascript
+// rgba is a 4 channel image with a fully-transparent alpha channel
+const rgba = await sharp(rgb)
+  .ensureAlpha(0)
+  .toBuffer();
+```
+
+*   Throws **[Error][3]** Invalid alpha transparency level
+
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.21.2
+*   **since**: 0.21.2
 
 ## extractChannel
 
@@ -42,21 +59,26 @@ Extract a single channel from a multi-channel image.
 
 ### Parameters
 
--   `channel` **([number][1] \| [string][2])** zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
+*   `channel` **([number][2] | [string][4])** zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
 
 ### Examples
 
 ```javascript
-sharp(input)
+// green.jpg is a greyscale image containing the green channel of the input
+await sharp(input)
   .extractChannel('green')
-  .toColourspace('b-w')
-  .toFile('green.jpg', function(err, info) {
-    // info.channels === 1
-    // green.jpg is a greyscale image containing the green channel of the input
-   });
+  .toFile('green.jpg');
 ```
 
--   Throws **[Error][3]** Invalid channel
+```javascript
+// red1 is the red value of the first pixel, red2 the second pixel etc.
+const [red1, red2, ...] = await sharp(input)
+  .extractChannel(0)
+  .raw()
+  .toBuffer();
+```
+
+*   Throws **[Error][3]** Invalid channel
 
 Returns **Sharp** 
 
@@ -67,19 +89,20 @@ The meaning of the added channels depends on the output colourspace, set with `t
 By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
 Channel ordering follows vips convention:
 
--   sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
--   CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
+*   sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
+*   CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
 
 Buffers may be any of the image formats supported by sharp.
 For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
 
 ### Parameters
 
--   `images` **([Array][4]<([string][2] \| [Buffer][5])> | [string][2] \| [Buffer][5])** one or more images (file paths, Buffers).
--   `options` **[Object][6]** image options, see `sharp()` constructor.
+*   `images` **([Array][5]<([string][4] | [Buffer][6])> | [string][4] | [Buffer][6])** one or more images (file paths, Buffers).
+*   `options` **[Object][7]** image options, see `sharp()` constructor.
 
+<!---->
 
--   Throws **[Error][3]** Invalid parameters
+*   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -89,7 +112,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][4]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
 
 ### Examples
 
@@ -103,18 +126,20 @@ sharp('3-channel-rgb-input.png')
   });
 ```
 
--   Throws **[Error][3]** Invalid parameters
+*   Throws **[Error][3]** Invalid parameters
 
 Returns **Sharp** 
 
-[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[1]: /api-operation#flatten
 
-[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
 [3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
 
-[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
 
-[5]: https://nodejs.org/api/buffer.html
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[6]: https://nodejs.org/api/buffer.html
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-colour.md

@@ -7,10 +7,11 @@ 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
+*   Throws **[Error][4]** Invalid parameter
 
 Returns **Sharp** 
 
@@ -25,7 +26,7 @@ An alpha channel may be present, and will be unchanged by the operation.
 
 ### Parameters
 
--   `greyscale` **[Boolean][5]**  (optional, default `true`)
+*   `greyscale` **[Boolean][5]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -35,7 +36,52 @@ Alternative spelling of `greyscale`.
 
 ### Parameters
 
--   `grayscale` **[Boolean][5]**  (optional, default `true`)
+*   `grayscale` **[Boolean][5]**  (optional, default `true`)
+
+Returns **Sharp** 
+
+## pipelineColourspace
+
+Set the pipeline colourspace.
+
+The input image will be converted to the provided colourspace at the start of the pipeline.
+All operations will use this colourspace before converting to the output colourspace, as defined by [toColourspace][6].
+
+This feature is experimental and has not yet been fully-tested with all operations.
+
+### Parameters
+
+*   `colourspace` **[string][1]?** pipeline colourspace e.g. `rgb16`, `scrgb`, `lab`, `grey16` [...][7]
+
+### Examples
+
+```javascript
+// Run pipeline in 16 bits per channel RGB while converting final result to 8 bits per channel sRGB.
+await sharp(input)
+ .pipelineColourspace('rgb16')
+ .toColourspace('srgb')
+ .toFile('16bpc-pipeline-to-8bpc-output.png')
+```
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp** 
+
+**Meta**
+
+*   **since**: 0.29.0
+
+## pipelineColorspace
+
+Alternative spelling of `pipelineColourspace`.
+
+### Parameters
+
+*   `colorspace` **[string][1]?** pipeline colorspace.
+
+<!---->
+
+*   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -46,7 +92,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` [...][8]
 
 ### Examples
 
@@ -57,7 +103,7 @@ await sharp(input)
  .toFile('16-bpp.png')
 ```
 
--   Throws **[Error][4]** Invalid parameters
+*   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -67,10 +113,11 @@ Alternative spelling of `toColourspace`.
 
 ### Parameters
 
--   `colorspace` **[string][1]?** output colorspace.
+*   `colorspace` **[string][1]?** output colorspace.
 
+<!---->
 
--   Throws **[Error][4]** Invalid parameters
+*   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -84,4 +131,8 @@ Returns **Sharp**
 
 [5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[6]: https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568
+[6]: #tocolourspace
+
+[7]: https://github.com/libvips/libvips/blob/41cff4e9d0838498487a00623462204eb10ee5b8/libvips/iofuncs/enumtypes.c#L774
+
+[8]: https://github.com/libvips/libvips/blob/3c0bfdf74ce1dc37a6429bed47fa76f16e2cd70a/libvips/iofuncs/enumtypes.c#L777-L794

docs/api-composite.md

@@ -19,24 +19,30 @@ 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 below)
-        -   `images[].input.create` **[Object][4]?** describes a blank overlay to be created.
-            -   `images[].input.create.width` **[Number][7]?** 
-            -   `images[].input.create.height` **[Number][7]?** 
-            -   `images[].input.create.channels` **[Number][7]?** 3-4
-            -   `images[].input.create.background` **([String][6] \| [Object][4])?** parsed by the [color][8] module to extract values for red, green, blue and alpha.
-    -   `images[].blend` **[String][6]** how to blend this image with the image below. (optional, default `'over'`)
-    -   `images[].gravity` **[String][6]** gravity at which to place the overlay. (optional, default `'centre'`)
-    -   `images[].top` **[Number][7]?** the pixel offset from the top edge.
-    -   `images[].left` **[Number][7]?** the pixel offset from the left edge.
-    -   `images[].tile` **[Boolean][9]** set to true to repeat the overlay image across the entire image with the given `gravity`. (optional, default `false`)
-    -   `images[].premultiplied` **[Boolean][9]** set to true to avoid premultipling the image below. Equivalent to the `--premultiplied` vips option. (optional, default `false`)
-    -   `images[].density` **[Number][7]** number representing the DPI for vector overlay image. (optional, default `72`)
-    -   `images[].raw` **[Object][4]?** describes overlay when using raw pixel data.
-        -   `images[].raw.width` **[Number][7]?** 
-        -   `images[].raw.height` **[Number][7]?** 
-        -   `images[].raw.channels` **[Number][7]?** 
+*   `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 below)
+
+        *   `images[].input.create` **[Object][4]?** describes a blank overlay to be created.
+
+            *   `images[].input.create.width` **[Number][7]?** 
+            *   `images[].input.create.height` **[Number][7]?** 
+            *   `images[].input.create.channels` **[Number][7]?** 3-4
+            *   `images[].input.create.background` **([String][6] | [Object][4])?** parsed by the [color][8] module to extract values for red, green, blue and alpha.
+    *   `images[].blend` **[String][6]** how to blend this image with the image below. (optional, default `'over'`)
+    *   `images[].gravity` **[String][6]** gravity at which to place the overlay. (optional, default `'centre'`)
+    *   `images[].top` **[Number][7]?** the pixel offset from the top edge.
+    *   `images[].left` **[Number][7]?** the pixel offset from the left edge.
+    *   `images[].tile` **[Boolean][9]** set to true to repeat the overlay image across the entire image with the given `gravity`. (optional, default `false`)
+    *   `images[].premultiplied` **[Boolean][9]** set to true to avoid premultipling the image below. Equivalent to the `--premultiplied` vips option. (optional, default `false`)
+    *   `images[].density` **[Number][7]** number representing the DPI for vector overlay image. (optional, default `72`)
+    *   `images[].raw` **[Object][4]?** describes overlay when using raw pixel data.
+
+        *   `images[].raw.width` **[Number][7]?** 
+        *   `images[].raw.height` **[Number][7]?** 
+        *   `images[].raw.channels` **[Number][7]?** 
+    *   `images[].failOnError` **[boolean][9]** @see [constructor parameters][10] (optional, default `true`)
+    *   `images[].limitInputPixels` **([number][7] | [boolean][9])** @see [constructor parameters][10] (optional, default `268402689`)
 
 ### Examples
 
@@ -57,13 +63,13 @@ sharp('input.png')
   });
 ```
 
--   Throws **[Error][10]** Invalid parameters
+*   Throws **[Error][11]** Invalid parameters
 
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.22.0
+*   **since**: 0.22.0
 
 [1]: https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
 
@@ -83,4 +89,6 @@ Returns **Sharp**
 
 [9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
 
-[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[10]: /api-constructor#parameters
+
+[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-constructor.md

@@ -4,7 +4,7 @@
 
 Constructor factory to create an instance of `sharp`, to which further methods are chained.
 
-JPEG, PNG, WebP, AVIF or TIFF format image data can be streamed out from this object.
+JPEG, PNG, WebP, GIF, AVIF or TIFF format image data can be streamed out from this object.
 When using Stream based output, derived attributes are available from the `info` event.
 
 Non-critical problems encountered during processing are emitted as `warning` events.
@@ -13,36 +13,45 @@ Implements the [stream.Duplex][1] class.
 
 ### Parameters
 
--   `input` **([Buffer][2] \| [Uint8Array][3] \| [Uint8ClampedArray][4] \| [string][5])?** if present, can be
-     a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
-     a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
-     JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
--   `options` **[Object][6]?** if present, is an Object with optional attributes.
-    -   `options.failOnError` **[boolean][7]** by default halt processing and raise an error when loading invalid images.
-         Set this flag to `false` if you'd rather apply a "best effort" to decode images, even if the data is corrupt or invalid. (optional, default `true`)
-    -   `options.limitInputPixels` **([number][8] \| [boolean][7])** Do not process input images where the number of pixels
-         (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
-         An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF). (optional, default `268402689`)
-    -   `options.sequentialRead` **[boolean][7]** Set this to `true` to use sequential rather than random access where possible.
-         This can reduce memory usage and might improve performance on some systems. (optional, default `false`)
-    -   `options.density` **[number][8]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
-    -   `options.pages` **[number][8]** number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
-    -   `options.page` **[number][8]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
-    -   `options.level` **[number][8]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
-    -   `options.animated` **[boolean][7]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
-    -   `options.raw` **[Object][6]?** describes raw pixel input image data. See `raw()` for pixel ordering.
-        -   `options.raw.width` **[number][8]?** integral number of pixels wide.
-        -   `options.raw.height` **[number][8]?** integral number of pixels high.
-        -   `options.raw.channels` **[number][8]?** integral number of channels, between 1 and 4.
-    -   `options.create` **[Object][6]?** describes a new image to be created.
-        -   `options.create.width` **[number][8]?** integral number of pixels wide.
-        -   `options.create.height` **[number][8]?** integral number of pixels high.
-        -   `options.create.channels` **[number][8]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
-        -   `options.create.background` **([string][5] \| [Object][6])?** parsed by the [color][9] module to extract values for red, green, blue and alpha.
-        -   `options.create.noise` **[Object][6]?** describes a noise to be created.
-            -   `options.create.noise.type` **[string][5]?** type of generated noise, currently only `gaussian` is supported.
-            -   `options.create.noise.mean` **[number][8]?** mean of pixels in generated noise.
-            -   `options.create.noise.sigma` **[number][8]?** standard deviation of pixels in generated noise.
+*   `input` **([Buffer][2] | [Uint8Array][3] | [Uint8ClampedArray][4] | [Int8Array][5] | [Uint16Array][6] | [Int16Array][7] | [Uint32Array][8] | [Int32Array][9] | [Float32Array][10] | [Float64Array][11] | [string][12])?** if present, can be
+    a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image data, or
+    a TypedArray containing raw pixel image data, or
+    a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
+    JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
+*   `options` **[Object][13]?** if present, is an Object with optional attributes.
+
+    *   `options.failOnError` **[boolean][14]** 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][15] | [boolean][14])** 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.unlimited` **[boolean][14]** Set this to `true` to remove safety features that help prevent memory exhaustion (SVG, PNG). (optional, default `false`)
+    *   `options.sequentialRead` **[boolean][14]** 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][15]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
+    *   `options.pages` **[number][15]** number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages. (optional, default `1`)
+    *   `options.page` **[number][15]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
+    *   `options.subifd` **[number][15]** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default `-1`)
+    *   `options.level` **[number][15]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    *   `options.animated` **[boolean][14]** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default `false`)
+    *   `options.raw` **[Object][13]?** describes raw pixel input image data. See `raw()` for pixel ordering.
+
+        *   `options.raw.width` **[number][15]?** integral number of pixels wide.
+        *   `options.raw.height` **[number][15]?** integral number of pixels high.
+        *   `options.raw.channels` **[number][15]?** integral number of channels, between 1 and 4.
+        *   `options.raw.premultiplied` **[boolean][14]?** specifies that the raw input has already been premultiplied, set to `true`
+            to avoid sharp premultiplying the image. (optional, default `false`)
+    *   `options.create` **[Object][13]?** describes a new image to be created.
+
+        *   `options.create.width` **[number][15]?** integral number of pixels wide.
+        *   `options.create.height` **[number][15]?** integral number of pixels high.
+        *   `options.create.channels` **[number][15]?** integral number of channels, either 3 (RGB) or 4 (RGBA).
+        *   `options.create.background` **([string][12] | [Object][13])?** parsed by the [color][16] module to extract values for red, green, blue and alpha.
+        *   `options.create.noise` **[Object][13]?** describes a noise to be created.
+
+            *   `options.create.noise.type` **[string][12]?** type of generated noise, currently only `gaussian` is supported.
+            *   `options.create.noise.mean` **[number][15]?** mean of pixels in generated noise.
+            *   `options.create.noise.sigma` **[number][15]?** standard deviation of pixels in generated noise.
 
 ### Examples
 
@@ -119,9 +128,9 @@ await sharp({
 }).toFile('noise.png');
 ```
 
--   Throws **[Error][10]** Invalid parameters
+*   Throws **[Error][17]** Invalid parameters
 
-Returns **[Sharp][11]** 
+Returns **[Sharp][18]** 
 
 ## clone
 
@@ -189,7 +198,7 @@ Promise.all(promises)
   });
 ```
 
-Returns **[Sharp][11]** 
+Returns **[Sharp][18]** 
 
 [1]: http://nodejs.org/api/stream.html#stream_class_stream_duplex
 
@@ -199,16 +208,30 @@ Returns **[Sharp][11]**
 
 [4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
 
-[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int8Array
 
-[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array
 
-[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int16Array
 
-[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array
 
-[9]: https://www.npmjs.org/package/color
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
 
-[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Float32Array
 
-[11]: #sharp
+[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+
+[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[14]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[16]: https://www.npmjs.org/package/color
+
+[17]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[18]: #sharp

docs/api-input.md

@@ -2,40 +2,52 @@
 
 ## metadata
 
-Fast access to (uncached) image metadata without decoding any compressed image data.
+Fast access to (uncached) image metadata without decoding any compressed pixel data.
+
+This is taken from the header of the input image.
+It does not include operations, such as resize, to be applied to the output image.
+
 A `Promise` is returned when `callback` is not provided.
 
--   `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
--   `size`: Total size of image in bytes, for Stream and Buffer input only
--   `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
--   `height`: Number of pixels high (EXIF orientation is not taken into consideration)
--   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][1]
--   `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
--   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][2]
--   `density`: Number of pixels per inch (DPI), if present
--   `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
--   `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
--   `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
--   `pageHeight`: Number of pixels high each page in a multi-page image will be.
--   `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
--   `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
--   `pagePrimary`: Number of the primary page in a HEIF image
--   `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
--   `hasProfile`: Boolean indicating the presence of an embedded ICC profile
--   `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
--   `orientation`: Number value of the EXIF Orientation header, if present
--   `exif`: Buffer containing raw EXIF data, if present
--   `icc`: Buffer containing raw [ICC][3] profile data, if present
--   `iptc`: Buffer containing raw IPTC data, if present
--   `xmp`: Buffer containing raw XMP data, if present
--   `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
+*   `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+*   `size`: Total size of image in bytes, for Stream and Buffer input only
+*   `width`: Number of pixels wide (EXIF orientation is not taken into consideration)
+*   `height`: Number of pixels high (EXIF orientation is not taken into consideration)
+*   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][1]
+*   `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+*   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][2]
+*   `density`: Number of pixels per inch (DPI), if present
+*   `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+*   `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+*   `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
+*   `pageHeight`: Number of pixels high each page in a multi-page image will be.
+*   `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
+*   `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
+*   `pagePrimary`: Number of the primary page in a HEIF image
+*   `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+*   `subifds`: Number of Sub Image File Directories in an OME-TIFF image
+*   `background`: Default background colour, if present, for PNG (bKGD) and GIF images, either an RGB Object or a single greyscale value
+*   `compression`: The encoder used to compress an HEIF file, `av1` (AVIF) or `hevc` (HEIC)
+*   `resolutionUnit`: The unit of resolution (density), either `inch` or `cm`, if present
+*   `hasProfile`: Boolean indicating the presence of an embedded ICC profile
+*   `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
+*   `orientation`: Number value of the EXIF Orientation header, if present
+*   `exif`: Buffer containing raw EXIF data, if present
+*   `icc`: Buffer containing raw [ICC][3] profile data, if present
+*   `iptc`: Buffer containing raw IPTC data, if present
+*   `xmp`: Buffer containing raw XMP data, if present
+*   `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
 
 ### Parameters
 
--   `callback` **[Function][4]?** called with the arguments `(err, metadata)`
+*   `callback` **[Function][4]?** called with the arguments `(err, metadata)`
 
 ### Examples
 
+```javascript
+const metadata = await sharp(input).metadata();
+```
+
 ```javascript
 const image = sharp(inputJpg);
 image
@@ -51,32 +63,35 @@ image
   });
 ```
 
-Returns **([Promise][5]<[Object][6]> | Sharp)** 
+Returns **([Promise][5]<[Object][6]> | Sharp)** 
 
 ## stats
 
 Access to pixel-derived image statistics for every channel in the image.
 A `Promise` is returned when `callback` is not provided.
 
--   `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
-    -   `min` (minimum value in the channel)
-    -   `max` (maximum value in the channel)
-    -   `sum` (sum of all values in a channel)
-    -   `squaresSum` (sum of squared values in a channel)
-    -   `mean` (mean of the values in a channel)
-    -   `stdev` (standard deviation for the values in a channel)
-    -   `minX` (x-coordinate of one of the pixel where the minimum lies)
-    -   `minY` (y-coordinate of one of the pixel where the minimum lies)
-    -   `maxX` (x-coordinate of one of the pixel where the maximum lies)
-    -   `maxY` (y-coordinate of one of the pixel where the maximum lies)
--   `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
--   `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
--   `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
--   `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
+*   `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
+    *   `min` (minimum value in the channel)
+    *   `max` (maximum value in the channel)
+    *   `sum` (sum of all values in a channel)
+    *   `squaresSum` (sum of squared values in a channel)
+    *   `mean` (mean of the values in a channel)
+    *   `stdev` (standard deviation for the values in a channel)
+    *   `minX` (x-coordinate of one of the pixel where the minimum lies)
+    *   `minY` (y-coordinate of one of the pixel where the minimum lies)
+    *   `maxX` (x-coordinate of one of the pixel where the maximum lies)
+    *   `maxY` (y-coordinate of one of the pixel where the maximum lies)
+*   `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
+*   `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental)
+*   `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
+*   `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
+
+**Note**: Statistics are derived from the original input image. Any operations performed on the image must first be
+written to a buffer in order to run `stats` on the result (see third example).
 
 ### Parameters
 
--   `callback` **[Function][4]?** called with the arguments `(err, stats)`
+*   `callback` **[Function][4]?** called with the arguments `(err, stats)`
 
 ### Examples
 
@@ -94,7 +109,15 @@ const { entropy, sharpness, dominant } = await sharp(input).stats();
 const { r, g, b } = dominant;
 ```
 
-Returns **[Promise][5]&lt;[Object][6]>** 
+```javascript
+const image = sharp(input);
+// store intermediate result
+const part = await image.extract(region).toBuffer();
+// create new instance to obtain statistics of extracted region
+const stats = await sharp(part).stats();
+```
+
+Returns **[Promise][5]<[Object][6]>** 
 
 [1]: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation
 

docs/api-operation.md

@@ -21,9 +21,10 @@ for example `rotate(x).extract(y)` will produce a different result to `extract(y
 
 ### Parameters
 
--   `angle` **[number][1]** angle of rotation. (optional, default `auto`)
--   `options` **[Object][2]?** if present, is an Object with optional attributes.
-    -   `options.background` **([string][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+*   `angle` **[number][1]** angle of rotation. (optional, default `auto`)
+*   `options` **[Object][2]?** if present, is an Object with optional attributes.
+
+    *   `options.background` **([string][3] | [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
 
 ### Examples
 
@@ -39,7 +40,7 @@ const pipeline = sharp()
 readableStream.pipe(pipeline);
 ```
 
--   Throws **[Error][5]** Invalid parameters
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -50,7 +51,7 @@ The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
 
 ### Parameters
 
--   `flip` **[Boolean][6]**  (optional, default `true`)
+*   `flip` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -61,7 +62,7 @@ The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
 
 ### Parameters
 
--   `flop` **[Boolean][6]**  (optional, default `true`)
+*   `flop` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -75,25 +76,26 @@ A particular interpolator may also be specified. Set the `interpolator` option t
 
 In the case of a 2x2 matrix, the transform is:
 
--   X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
--   Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
+*   X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
+*   Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
 
 where:
 
--   x and y are the coordinates in input image.
--   X and Y are the coordinates in output image.
--   (0,0) is the upper left corner.
+*   x and y are the coordinates in input image.
+*   X and Y are the coordinates in output image.
+*   (0,0) is the upper left corner.
 
 ### Parameters
 
--   `matrix` **([Array][7]<[Array][7]<[number][1]>> | [Array][7]<[number][1]>)** affine transformation matrix
--   `options` **[Object][2]?** if present, is an Object with optional attributes.
-    -   `options.background` **([String][3] \| [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
-    -   `options.idx` **[Number][1]** input horizontal offset (optional, default `0`)
-    -   `options.idy` **[Number][1]** input vertical offset (optional, default `0`)
-    -   `options.odx` **[Number][1]** output horizontal offset (optional, default `0`)
-    -   `options.ody` **[Number][1]** output vertical offset (optional, default `0`)
-    -   `options.interpolator` **[String][3]** interpolator (optional, default `sharp.interpolators.bicubic`)
+*   `matrix` **([Array][7]<[Array][7]<[number][1]>> | [Array][7]<[number][1]>)** affine transformation matrix
+*   `options` **[Object][2]?** if present, is an Object with optional attributes.
+
+    *   `options.background` **([String][3] | [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+    *   `options.idx` **[Number][1]** input horizontal offset (optional, default `0`)
+    *   `options.idy` **[Number][1]** input vertical offset (optional, default `0`)
+    *   `options.odx` **[Number][1]** output horizontal offset (optional, default `0`)
+    *   `options.ody` **[Number][1]** output vertical offset (optional, default `0`)
+    *   `options.interpolator` **[String][3]** interpolator (optional, default `sharp.interpolators.bicubic`)
 
 ### Examples
 
@@ -112,13 +114,13 @@ inputStream
   .pipe(pipeline);
 ```
 
--   Throws **[Error][5]** Invalid parameters
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.27.0
+*   **since**: 0.27.0
 
 ## sharpen
 
@@ -129,12 +131,13 @@ 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
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -145,25 +148,41 @@ 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
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
 ## blur
 
 Blur the image.
-When used without parameters, performs a fast, mild blur of the output image.
+
+When used without parameters, performs a fast 3x3 box blur (equivalent to a box linear filter).
+
 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`.
 
+### Examples
 
--   Throws **[Error][5]** Invalid parameters
+```javascript
+const boxBlurred = await sharp(input)
+  .blur()
+  .toBuffer();
+```
+
+```javascript
+const gaussianBlurred = await sharp(input)
+  .blur(5)
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -171,16 +190,19 @@ Returns **Sharp**
 
 Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
 
+See also [removeAlpha][8].
+
 ### 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` **[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}`)
 
 ### Examples
 
 ```javascript
 await sharp(rgbaInput)
-  .flatten('#F0A703')
+  .flatten({ background: '#F0A703' })
   .toBuffer();
 ```
 
@@ -198,11 +220,12 @@ 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
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -212,7 +235,9 @@ Produce the "negative" of the image.
 
 ### Parameters
 
--   `negate` **[Boolean][6]**  (optional, default `true`)
+*   `options` **[Object][2]?** 
+
+    *   `options.alpha` **[Boolean][6]** Whether or not to negate any alpha channel (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -222,7 +247,7 @@ Enhance output image contrast by stretching its luminance to cover the full dyna
 
 ### Parameters
 
--   `normalise` **[Boolean][6]**  (optional, default `true`)
+*   `normalise` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
@@ -232,22 +257,50 @@ Alternative spelling of normalise.
 
 ### Parameters
 
--   `normalize` **[Boolean][6]**  (optional, default `true`)
+*   `normalize` **[Boolean][6]**  (optional, default `true`)
 
 Returns **Sharp** 
 
+## clahe
+
+Perform contrast limiting adaptive histogram equalization
+[CLAHE][9].
+
+This will, in general, enhance the clarity of the image by bringing out darker details.
+
+### Parameters
+
+*   `options` **[Object][2]** 
+
+    *   `options.width` **[number][1]** integer width of the region in pixels.
+    *   `options.height` **[number][1]** integer height of the region in pixels.
+    *   `options.maxSlope` **[number][1]** maximum value for the slope of the
+        cumulative histogram. A value of 0 disables contrast limiting. Valid values
+        are integers in the range 0-100 (inclusive) (optional, default `3`)
+
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+**Meta**
+
+*   **since**: 0.28.3
+
 ## convolve
 
 Convolve the image with the specified kernel.
 
 ### Parameters
 
--   `kernel` **[Object][2]** 
-    -   `kernel.width` **[number][1]** width of the kernel in pixels.
-    -   `kernel.height` **[number][1]** width of the kernel in pixels.
-    -   `kernel.kernel` **[Array][7]&lt;[number][1]>** Array of length `width*height` containing the kernel values.
-    -   `kernel.scale` **[number][1]** the scale of the kernel in pixels. (optional, default `sum`)
-    -   `kernel.offset` **[number][1]** the offset of the kernel in pixels. (optional, default `0`)
+*   `kernel` **[Object][2]** 
+
+    *   `kernel.width` **[number][1]** width of the kernel in pixels.
+    *   `kernel.height` **[number][1]** height 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
 
@@ -265,7 +318,7 @@ sharp(input)
   });
 ```
 
--   Throws **[Error][5]** Invalid parameters
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -275,13 +328,15 @@ Any pixel value greater 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`)
--   `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`)
+*   `threshold` **[number][1]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
+*   `options` **[Object][2]?** 
 
+    *   `options.greyscale` **[Boolean][6]** convert to single channel greyscale. (optional, default `true`)
+    *   `options.grayscale` **[Boolean][6]** alternative spelling for greyscale. (optional, default `true`)
 
--   Throws **[Error][5]** Invalid parameters
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -294,16 +349,19 @@ 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.
--   `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]?** 
+*   `operand` **([Buffer][10] | [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.
 
--   Throws **[Error][5]** Invalid parameters
+        *   `options.raw.width` **[number][1]?** 
+        *   `options.raw.height` **[number][1]?** 
+        *   `options.raw.channels` **[number][1]?** 
+
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -313,11 +371,12 @@ 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
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -327,7 +386,7 @@ Recomb the image with the specified matrix.
 
 ### Parameters
 
--   `inputMatrix` **[Array][7]&lt;[Array][7]&lt;[number][1]>>** 3x3 Recombination matrix
+*   `inputMatrix` **[Array][7]<[Array][7]<[number][1]>>** 3x3 Recombination matrix
 
 ### Examples
 
@@ -345,31 +404,35 @@ sharp(input)
   });
 ```
 
--   Throws **[Error][5]** Invalid parameters
+*   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.21.1
+*   **since**: 0.21.1
 
 ## modulate
 
-Transforms the image using brightness, saturation and hue rotation.
+Transforms the image using brightness, saturation, hue rotation, and lightness.
+Brightness and lightness both operate on luminance, with the difference being that
+brightness is multiplicative whereas lightness is additive.
 
 ### 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` **[Object][2]?** 
+
+    *   `options.brightness` **[number][1]?** Brightness multiplier
+    *   `options.saturation` **[number][1]?** Saturation multiplier
+    *   `options.hue` **[number][1]?** Degrees for hue rotation
+    *   `options.lightness` **[number][1]?** Lightness addend
 
 ### Examples
 
 ```javascript
 sharp(input)
   .modulate({
-    brightness: 2 // increase lightness by a factor of 2
+    brightness: 2 // increase brightness by a factor of 2
   });
 
 sharp(input)
@@ -377,6 +440,11 @@ sharp(input)
     hue: 180 // hue-rotate by 180 degrees
   });
 
+sharp(input)
+  .modulate({
+    lightness: 50 // increase lightness by +50
+  });
+
 // decreate brightness and saturation while also hue-rotating by 90 degrees
 sharp(input)
   .modulate({
@@ -390,7 +458,7 @@ Returns **Sharp**
 
 **Meta**
 
--   **since**: 0.22.1
+*   **since**: 0.22.1
 
 [1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
 
@@ -406,4 +474,8 @@ Returns **Sharp**
 
 [7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
-[8]: https://nodejs.org/api/buffer.html
+[8]: /api-channel#removealpha
+
+[9]: https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_AHE
+
+[10]: https://nodejs.org/api/buffer.html

docs/api-output.md

@@ -5,18 +5,20 @@
 Write output image data to a file.
 
 If an explicit output format is not selected, it will be inferred from the extension,
-with JPEG, PNG, WebP, AVIF, TIFF, DZI, and libvips' V format supported.
+with JPEG, PNG, WebP, AVIF, TIFF, GIF, DZI, and libvips' V format supported.
 Note that raw pixel data is only supported for buffer output.
 
 By default all metadata will be removed, which includes EXIF-based orientation.
 See [withMetadata][1] for control over this.
 
+The caller is responsible for ensuring directory structures and permissions exist.
+
 A `Promise` is returned when `callback` is not provided.
 
 ### Parameters
 
--   `fileOut` **[string][2]** the path to write the image data to.
--   `callback` **[Function][3]?** called on completion with two arguments `(err, info)`.
+*   `fileOut` **[string][2]** the path to write the image data to.
+*   `callback` **[Function][3]?** called on completion with two arguments `(err, info)`.
     `info` contains the output image `format`, `size` (bytes), `width`, `height`,
     `channels` and `premultiplied` (indicating if premultiplication was used).
     When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
@@ -35,35 +37,37 @@ sharp(input)
   .catch(err => { ... });
 ```
 
--   Throws **[Error][4]** Invalid parameters
+*   Throws **[Error][4]** Invalid parameters
 
-Returns **[Promise][5]<[Object][6]>** when no callback is provided
+Returns **[Promise][5]<[Object][6]>** when no callback is provided
 
 ## toBuffer
 
 Write output to a Buffer.
-JPEG, PNG, WebP, AVIF, TIFF and raw pixel data output are supported.
+JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
 
-If no explicit format is set, the output format will match the input image, except GIF and SVG input which become PNG output.
+If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
 
 By default all metadata will be removed, which includes EXIF-based orientation.
 See [withMetadata][1] for control over this.
 
 `callback`, if present, gets three arguments `(err, data, info)` where:
 
--   `err` is an error, if any.
--   `data` is the output image data.
--   `info` contains the output image `format`, `size` (bytes), `width`, `height`,
-    `channels` and `premultiplied` (indicating if premultiplication was used).
-    When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+*   `err` is an error, if any.
+*   `data` is the output image data.
+*   `info` contains the output image `format`, `size` (bytes), `width`, `height`,
+
+`channels` and `premultiplied` (indicating if premultiplication was used).
+When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
 
 A `Promise` is returned when `callback` is not provided.
 
 ### Parameters
 
--   `options` **[Object][6]?** 
-    -   `options.resolveWithObject` **[boolean][7]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
--   `callback` **[Function][3]?** 
+*   `options` **[Object][6]?** 
+
+    *   `options.resolveWithObject` **[boolean][7]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+*   `callback` **[Function][3]?** 
 
 ### Examples
 
@@ -103,7 +107,7 @@ await sharp(pixelArray, { raw: { width, height, channels } })
   .toFile('my-changed-image.jpg');
 ```
 
-Returns **[Promise][5]&lt;[Buffer][8]>** when no callback is provided
+Returns **[Promise][5]<[Buffer][8]>** when no callback is provided
 
 ## withMetadata
 
@@ -116,9 +120,12 @@ sRGB colour space and strip all metadata, including the removal of any ICC profi
 
 ### Parameters
 
--   `options` **[Object][6]?** 
-    -   `options.orientation` **[number][9]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
-    -   `options.icc` **[string][2]?** filesystem path to output ICC profile, defaults to sRGB.
+*   `options` **[Object][6]?** 
+
+    *   `options.orientation` **[number][9]?** value between 1 and 8, used to update the EXIF `Orientation` tag.
+    *   `options.icc` **[string][2]?** filesystem path to output ICC profile, defaults to sRGB.
+    *   `options.exif` **[Object][6]<[Object][6]>** Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data. (optional, default `{}`)
+    *   `options.density` **[number][9]?** Number of pixels per inch (DPI).
 
 ### Examples
 
@@ -129,7 +136,27 @@ sharp('input.jpg')
   .then(info => { ... });
 ```
 
--   Throws **[Error][4]** Invalid parameters
+```javascript
+// Set "IFD0-Copyright" in output EXIF metadata
+const data = await sharp(input)
+  .withMetadata({
+    exif: {
+      IFD0: {
+        Copyright: 'Wernham Hogg'
+      }
+    }
+  })
+  .toBuffer();
+```
+
+```javascript
+// Set output metadata to 96 DPI
+const data = await sharp(input)
+  .withMetadata({ density: 96 })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -139,8 +166,8 @@ Force output to a given format.
 
 ### Parameters
 
--   `format` **([string][2] \| [Object][6])** as a string or an Object with an 'id' attribute
--   `options` **[Object][6]** output options
+*   `format` **([string][2] | [Object][6])** as a string or an Object with an 'id' attribute
+*   `options` **[Object][6]** output options
 
 ### Examples
 
@@ -151,7 +178,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][4]** unsupported format or options
+*   Throws **[Error][4]** unsupported format or options
 
 Returns **Sharp** 
 
@@ -161,20 +188,21 @@ Use these JPEG options for output image.
 
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling (optional, default `'4:2:0'`)
-    -   `options.optimiseCoding` **[boolean][7]** optimise Huffman coding tables (optional, default `true`)
-    -   `options.optimizeCoding` **[boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
-    -   `options.mozjpeg` **[boolean][7]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
-    -   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation (optional, default `false`)
-    -   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing (optional, default `false`)
-    -   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive (optional, default `false`)
-    -   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans (optional, default `false`)
-    -   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8 (optional, default `0`)
-    -   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable (optional, default `0`)
-    -   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    *   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    *   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling (optional, default `'4:2:0'`)
+    *   `options.optimiseCoding` **[boolean][7]** optimise Huffman coding tables (optional, default `true`)
+    *   `options.optimizeCoding` **[boolean][7]** alternative spelling of optimiseCoding (optional, default `true`)
+    *   `options.mozjpeg` **[boolean][7]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
+    *   `options.trellisQuantisation` **[boolean][7]** apply trellis quantisation (optional, default `false`)
+    *   `options.overshootDeringing` **[boolean][7]** apply overshoot deringing (optional, default `false`)
+    *   `options.optimiseScans` **[boolean][7]** optimise progressive scans, forces progressive (optional, default `false`)
+    *   `options.optimizeScans` **[boolean][7]** alternative spelling of optimiseScans (optional, default `false`)
+    *   `options.quantisationTable` **[number][9]** quantization table to use, integer 0-8 (optional, default `0`)
+    *   `options.quantizationTable` **[number][9]** alternative spelling of quantisationTable (optional, default `0`)
+    *   `options.force` **[boolean][7]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -195,7 +223,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][4]** Invalid options
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
@@ -209,16 +237,18 @@ Set `palette` to `true` for slower, indexed PNG output.
 
 ### Parameters
 
--   `options` **[Object][6]?** 
-    -   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
-    -   `options.compressionLevel` **[number][9]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
-    -   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
-    -   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
-    -   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
-    -   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
-    -   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
-    -   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
-    -   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+*   `options` **[Object][6]?** 
+
+    *   `options.progressive` **[boolean][7]** use progressive (interlace) scan (optional, default `false`)
+    *   `options.compressionLevel` **[number][9]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
+    *   `options.adaptiveFiltering` **[boolean][7]** use adaptive row filtering (optional, default `false`)
+    *   `options.palette` **[boolean][7]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
+    *   `options.quality` **[number][9]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
+    *   `options.effort` **[number][9]** CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true` (optional, default `7`)
+    *   `options.colours` **[number][9]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
+    *   `options.colors` **[number][9]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
+    *   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
+    *   `options.force` **[boolean][7]** force PNG output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -236,7 +266,7 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][4]** Invalid options
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
@@ -246,17 +276,17 @@ Use these WebP options for output image.
 
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    -   `options.alphaQuality` **[number][9]** quality of alpha layer, integer 0-100 (optional, default `100`)
-    -   `options.lossless` **[boolean][7]** use lossless compression mode (optional, default `false`)
-    -   `options.nearLossless` **[boolean][7]** use near_lossless compression mode (optional, default `false`)
-    -   `options.smartSubsample` **[boolean][7]** use high quality chroma subsampling (optional, default `false`)
-    -   `options.reductionEffort` **[number][9]** level of CPU effort to reduce file size, integer 0-6 (optional, default `4`)
-    -   `options.pageHeight` **[number][9]?** page height for animated output
-    -   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
-    -   `options.delay` **[Array][10]&lt;[number][9]>?** list of delays between animation frames (in milliseconds)
-    -   `options.force` **[boolean][7]** force WebP output, otherwise attempt to use input format (optional, default `true`)
+*   `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.effort` **[number][9]** CPU effort, between 0 (fastest) and 6 (slowest) (optional, default `4`)
+    *   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][9] | [Array][10]<[number][9]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.force` **[boolean][7]** force WebP output, otherwise attempt to use input format (optional, default `true`)
 
 ### Examples
 
@@ -267,49 +297,133 @@ const data = await sharp(input)
   .toBuffer();
 ```
 
--   Throws **[Error][4]** Invalid options
+```javascript
+// Optimise the file size of an animated WebP
+const outputWebp = await sharp(inputWebp, { animated: true })
+  .webp({ effort: 6 })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
 ## gif
 
-Use these GIF options for output image.
+Use these GIF options for the output image.
 
-Requires libvips compiled with support for ImageMagick or GraphicsMagick.
+The first entry in the palette is reserved for transparency.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.colours` **[number][9]** maximum number of palette entries, including transparency, between 2 and 256 (optional, default `256`)
+    *   `options.colors` **[number][9]** alternative spelling of `options.colours` (optional, default `256`)
+    *   `options.effort` **[number][9]** CPU effort, between 1 (fastest) and 10 (slowest) (optional, default `7`)
+    *   `options.dither` **[number][9]** level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default `1.0`)
+    *   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][9] | [Array][10]<[number][9]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.force` **[boolean][7]** force GIF output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert PNG to GIF
+await sharp(pngBuffer)
+  .gif()
+  .toBuffer());
+```
+
+```javascript
+// Convert animated WebP to animated GIF
+await sharp('animated.webp', { animated: true })
+  .toFile('animated.gif');
+```
+
+```javascript
+// Create a 128x128, cropped, non-dithered, animated thumbnail of an animated GIF
+const out = await sharp('in.gif', { animated: true })
+  .resize({ width: 128, height: 128 })
+  .gif({ dither: 0 })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp** 
+
+**Meta**
+
+*   **since**: 0.30.0
+
+## jp2
+
+Use these JP2 options for output image.
+
+Requires libvips compiled with support for OpenJPEG.
 The prebuilt binaries do not include this - see
 [installing a custom libvips][11].
 
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.pageHeight` **[number][9]?** page height for animated output
-    -   `options.loop` **[number][9]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
-    -   `options.delay` **[Array][10]&lt;[number][9]>?** list of delays between animation frames (in milliseconds)
-    -   `options.force` **[boolean][7]** force GIF output, otherwise attempt to use input format (optional, default `true`)
+*   `options` **[Object][6]?** output options
 
+    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    *   `options.lossless` **[boolean][7]** use lossless compression mode (optional, default `false`)
+    *   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `512`)
+    *   `options.tileHeight` **[number][9]** vertical tile size (optional, default `512`)
+    *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
--   Throws **[Error][4]** Invalid options
+### Examples
+
+```javascript
+// Convert any input to lossless JP2 output
+const data = await sharp(input)
+  .jp2({ lossless: true })
+  .toBuffer();
+```
+
+```javascript
+// Convert any input to very high quality JP2 output
+const data = await sharp(input)
+  .jp2({
+    quality: 100,
+    chromaSubsampling: '4:4:4'
+  })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
+**Meta**
+
+*   **since**: 0.29.1
+
 ## tiff
 
 Use these TIFF options for output image.
 
+The `density` can be set in pixels/inch via [withMetadata][1] instead of providing `xres` and `yres` in pixels/mm.
+
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
-    -   `options.force` **[boolean][7]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
-    -   `options.compression` **[string][2]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
-    -   `options.predictor` **[string][2]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
-    -   `options.pyramid` **[boolean][7]** write an image pyramid (optional, default `false`)
-    -   `options.tile` **[boolean][7]** write a tiled tiff (optional, default `false`)
-    -   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `256`)
-    -   `options.tileHeight` **[number][9]** vertical tile size (optional, default `256`)
-    -   `options.xres` **[number][9]** horizontal resolution in pixels/mm (optional, default `1.0`)
-    -   `options.yres` **[number][9]** vertical resolution in pixels/mm (optional, default `1.0`)
-    -   `options.bitdepth` **[number][9]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `80`)
+    *   `options.force` **[boolean][7]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.compression` **[string][2]** compression options: lzw, deflate, jpeg, ccittfax4 (optional, default `'jpeg'`)
+    *   `options.predictor` **[string][2]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
+    *   `options.pyramid` **[boolean][7]** write an image pyramid (optional, default `false`)
+    *   `options.tile` **[boolean][7]** write a tiled tiff (optional, default `false`)
+    *   `options.tileWidth` **[number][9]** horizontal tile size (optional, default `256`)
+    *   `options.tileHeight` **[number][9]** vertical tile size (optional, default `256`)
+    *   `options.xres` **[number][9]** horizontal resolution in pixels/mm (optional, default `1.0`)
+    *   `options.yres` **[number][9]** vertical resolution in pixels/mm (optional, default `1.0`)
+    *   `options.resolutionUnit` **[string][2]** resolution unit options: inch, cm (optional, default `'inch'`)
+    *   `options.bitdepth` **[number][9]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
 
 ### Examples
 
@@ -324,7 +438,7 @@ sharp('input.svg')
   .then(info => { ... });
 ```
 
--   Throws **[Error][4]** Invalid options
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
@@ -335,22 +449,26 @@ Use these AVIF options for output image.
 Whilst it is possible to create AVIF images smaller than 16x16 pixels,
 most web browsers do not display these properly.
 
+AVIF image sequences are not supported.
+
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
-    -   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
-    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
-    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
+*   `options` **[Object][6]?** output options
 
+    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
+    *   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][9]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
+    *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
--   Throws **[Error][4]** Invalid options
+<!---->
+
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.27.0
+*   **since**: 0.27.0
 
 ## heif
 
@@ -361,48 +479,56 @@ globally-installed libvips compiled with support for libheif, libde265 and x265.
 
 ### Parameters
 
--   `options` **[Object][6]?** output options
-    -   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
-    -   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
-    -   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
-    -   `options.speed` **[number][9]** CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest) (optional, default `5`)
-    -   `options.chromaSubsampling` **[string][2]** set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0 (optional, default `'4:2:0'`)
+*   `options` **[Object][6]?** output options
 
+    *   `options.quality` **[number][9]** quality, integer 1-100 (optional, default `50`)
+    *   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
+    *   `options.lossless` **[boolean][7]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][9]** CPU effort, between 0 (fastest) and 9 (slowest) (optional, default `4`)
+    *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
 
--   Throws **[Error][4]** Invalid options
+<!---->
+
+*   Throws **[Error][4]** Invalid options
 
 Returns **Sharp** 
 
 **Meta**
 
--   **since**: 0.23.0
+*   **since**: 0.23.0
 
 ## raw
 
-Force output to be raw, uncompressed, 8-bit unsigned integer (unit8) pixel data.
+Force output to be raw, uncompressed pixel data.
 Pixel ordering is left-to-right, top-to-bottom, without padding.
 Channel ordering will be RGB or RGBA for non-greyscale colourspaces.
 
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.depth` **[string][2]** bit depth, one of: char, uchar (default), short, ushort, int, uint, float, complex, double, dpcomplex (optional, default `'uchar'`)
+
 ### Examples
 
 ```javascript
-// Extract raw RGB pixel data from JPEG input
+// Extract raw, unsigned 8-bit RGB pixel data from JPEG input
 const { data, info } = await sharp('input.jpg')
   .raw()
   .toBuffer({ resolveWithObject: true });
 ```
 
 ```javascript
-// Extract alpha channel as raw pixel data from PNG input
+// Extract alpha channel as raw, unsigned 16-bit pixel data from PNG input
 const data = await sharp('input.png')
   .ensureAlpha()
   .extractChannel(3)
   .toColourspace('b-w')
-  .raw()
+  .raw({ depth: 'ushort' })
   .toBuffer();
 ```
 
-Returns **Sharp** 
+*   Throws **[Error][4]** Invalid options
 
 ## tile
 
@@ -410,22 +536,21 @@ Use tile-based deep zoom (image pyramid) output.
 Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
 Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
 
-Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
-
 ### Parameters
 
--   `options` **[Object][6]?** 
-    -   `options.size` **[number][9]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
-    -   `options.overlap` **[number][9]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
-    -   `options.angle` **[number][9]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
-    -   `options.background` **([string][2] \| [Object][6])** background colour, parsed by the [color][12] module, defaults to white without transparency. (optional, default `{r:255,g:255,b:255,alpha:1}`)
-    -   `options.depth` **[string][2]?** how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
-    -   `options.skipBlanks` **[number][9]** threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images (optional, default `-1`)
-    -   `options.container` **[string][2]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
-    -   `options.layout` **[string][2]** filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`. (optional, default `'dz'`)
-    -   `options.centre` **[boolean][7]** centre image in tile. (optional, default `false`)
-    -   `options.center` **[boolean][7]** alternative spelling of centre. (optional, default `false`)
-    -   `options.id` **[string][2]** when `layout` is `iiif`, sets the `@id` attribute of `info.json` (optional, default `'https://example.com/iiif'`)
+*   `options` **[Object][6]?** 
+
+    *   `options.size` **[number][9]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
+    *   `options.overlap` **[number][9]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
+    *   `options.angle` **[number][9]** tile angle of rotation, must be a multiple of 90. (optional, default `0`)
+    *   `options.background` **([string][2] | [Object][6])** background colour, parsed by the [color][12] module, defaults to white without transparency. (optional, default `{r:255,g:255,b:255,alpha:1}`)
+    *   `options.depth` **[string][2]?** how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
+    *   `options.skipBlanks` **[number][9]** threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images (optional, default `-1`)
+    *   `options.container` **[string][2]** tile container, with value `fs` (filesystem) or `zip` (compressed file). (optional, default `'fs'`)
+    *   `options.layout` **[string][2]** filesystem layout, possible values are `dz`, `iiif`, `iiif3`, `zoomify` or `google`. (optional, default `'dz'`)
+    *   `options.centre` **[boolean][7]** centre image in tile. (optional, default `false`)
+    *   `options.center` **[boolean][7]** alternative spelling of centre. (optional, default `false`)
+    *   `options.id` **[string][2]** when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json` (optional, default `'https://example.com/iiif'`)
 
 ### Examples
 
@@ -441,10 +566,30 @@ sharp('input.tiff')
   });
 ```
 
--   Throws **[Error][4]** Invalid parameters
+*   Throws **[Error][4]** Invalid parameters
 
 Returns **Sharp** 
 
+## timeout
+
+Set a timeout for processing, in seconds.
+Use a value of zero to continue processing indefinitely, the default behaviour.
+
+The clock starts when libvips opens an input image for processing.
+Time spent waiting for a libuv thread to become available is not included.
+
+### Parameters
+
+*   `options` **[Object][6]** 
+
+    *   `options.seconds` **[number][9]** Number of seconds after which processing will be stopped
+
+Returns **Sharp** 
+
+**Meta**
+
+*   **since**: 0.29.2
+
 [1]: #withmetadata
 
 [2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String

docs/api-resize.md

@@ -6,49 +6,51 @@ Resize image to `width`, `height` or `width x height`.
 
 When both a `width` and `height` are provided, the possible methods by which the image should **fit** these are:
 
--   `cover`: (default) Preserving aspect ratio, ensure the image covers both provided dimensions by cropping/clipping to fit.
--   `contain`: Preserving aspect ratio, contain within both provided dimensions using "letterboxing" where necessary.
--   `fill`: Ignore the aspect ratio of the input and stretch to both provided dimensions.
--   `inside`: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
--   `outside`: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
+*   `cover`: (default) Preserving aspect ratio, ensure the image covers both provided dimensions by cropping/clipping to fit.
+*   `contain`: Preserving aspect ratio, contain within both provided dimensions using "letterboxing" where necessary.
+*   `fill`: Ignore the aspect ratio of the input and stretch to both provided dimensions.
+*   `inside`: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
+*   `outside`: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
 
 Some of these values are based on the [object-fit][1] CSS property.
 
 When using a `fit` of `cover` or `contain`, the default **position** is `centre`. Other options are:
 
--   `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
--   `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
--   `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
+*   `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
+*   `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
+*   `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
 
 Some of these values are based on the [object-position][2] CSS property.
 
 The experimental strategy-based approach resizes so one dimension is at its target length
 then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
 
--   `entropy`: focus on the region with the highest [Shannon entropy][3].
--   `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
+*   `entropy`: focus on the region with the highest [Shannon entropy][3].
+*   `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
 
 Possible interpolation kernels are:
 
--   `nearest`: Use [nearest neighbour interpolation][4].
--   `cubic`: Use a [Catmull-Rom spline][5].
--   `mitchell`: Use a [Mitchell-Netravali spline][6].
--   `lanczos2`: Use a [Lanczos kernel][7] with `a=2`.
--   `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
+*   `nearest`: Use [nearest neighbour interpolation][4].
+*   `cubic`: Use a [Catmull-Rom spline][5].
+*   `mitchell`: Use a [Mitchell-Netravali spline][6].
+*   `lanczos2`: Use a [Lanczos kernel][7] with `a=2`.
+*   `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
 
 ### Parameters
 
--   `width` **[number][8]?** pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
--   `height` **[number][8]?** pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
--   `options` **[Object][9]?** 
-    -   `options.width` **[String][10]?** alternative means of specifying `width`. If both are present this take priority.
-    -   `options.height` **[String][10]?** alternative means of specifying `height`. If both are present this take priority.
-    -   `options.fit` **[String][10]** how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`. (optional, default `'cover'`)
-    -   `options.position` **[String][10]** position, gravity or strategy to use when `fit` is `cover` or `contain`. (optional, default `'centre'`)
-    -   `options.background` **([String][10] \| [Object][9])** background colour when using a `fit` of `contain`, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
-    -   `options.kernel` **[String][10]** the kernel to use for image reduction. (optional, default `'lanczos3'`)
-    -   `options.withoutEnlargement` **[Boolean][12]** do not enlarge if the width _or_ height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. (optional, default `false`)
-    -   `options.fastShrinkOnLoad` **[Boolean][12]** take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images. (optional, default `true`)
+*   `width` **[number][8]?** pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+*   `height` **[number][8]?** pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+*   `options` **[Object][9]?** 
+
+    *   `options.width` **[String][10]?** alternative means of specifying `width`. If both are present this take priority.
+    *   `options.height` **[String][10]?** alternative means of specifying `height`. If both are present this take priority.
+    *   `options.fit` **[String][10]** how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`. (optional, default `'cover'`)
+    *   `options.position` **[String][10]** position, gravity or strategy to use when `fit` is `cover` or `contain`. (optional, default `'centre'`)
+    *   `options.background` **([String][10] | [Object][9])** background colour when using a `fit` of `contain`, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
+    *   `options.kernel` **[String][10]** the kernel to use for image reduction. (optional, default `'lanczos3'`)
+    *   `options.withoutEnlargement` **[Boolean][12]** do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. (optional, default `false`)
+    *   `options.withoutReduction` **[Boolean][12]** do not reduce if the width *or* height are already greater than the specified dimensions, equivalent to GraphicsMagick's `<` geometry option. (optional, default `false`)
+    *   `options.fastShrinkOnLoad` **[Boolean][12]** take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images. (optional, default `true`)
 
 ### Examples
 
@@ -116,6 +118,21 @@ sharp(input)
   });
 ```
 
+```javascript
+sharp(input)
+  .resize(200, 200, {
+    fit: sharp.fit.outside,
+    withoutReduction: true
+  })
+  .toFormat('jpeg')
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains JPEG image data
+    // of at least 200 pixels wide and 200 pixels high while maintaining aspect ratio
+    // and no smaller than the input image
+  });
+```
+
 ```javascript
 const scaleByHalf = await sharp(input)
   .metadata()
@@ -125,7 +142,7 @@ const scaleByHalf = await sharp(input)
   );
 ```
 
--   Throws **[Error][13]** Invalid parameters
+*   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -136,12 +153,13 @@ 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]**  (optional, default `0`)
-    -   `extend.left` **[number][8]**  (optional, default `0`)
-    -   `extend.bottom` **[number][8]**  (optional, default `0`)
-    -   `extend.right` **[number][8]**  (optional, default `0`)
-    -   `extend.background` **([String][10] \| [Object][9])** background colour, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
+*   `extend` **([number][8] | [Object][9])** single pixel count to add to all edges or an Object with per-edge counts
+
+    *   `extend.top` **[number][8]**  (optional, default `0`)
+    *   `extend.left` **[number][8]**  (optional, default `0`)
+    *   `extend.bottom` **[number][8]**  (optional, default `0`)
+    *   `extend.right` **[number][8]**  (optional, default `0`)
+    *   `extend.background` **([String][10] | [Object][9])** background colour, parsed by the [color][11] module, defaults to black without transparency. (optional, default `{r:0,g:0,b:0,alpha:1}`)
 
 ### Examples
 
@@ -170,7 +188,7 @@ sharp(input)
   ...
 ```
 
--   Throws **[Error][13]** Invalid parameters
+*   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -178,17 +196,18 @@ Returns **Sharp**
 
 Extract/crop a region of the image.
 
--   Use `extract` before `resize` for pre-resize extraction.
--   Use `extract` after `resize` for post-resize extraction.
--   Use `extract` before and after for both.
+*   Use `extract` before `resize` for pre-resize extraction.
+*   Use `extract` after `resize` for post-resize extraction.
+*   Use `extract` before and after for both.
 
 ### Parameters
 
--   `options` **[Object][9]** describes the region to extract using integral pixel values
-    -   `options.left` **[number][8]** zero-indexed offset from left edge
-    -   `options.top` **[number][8]** zero-indexed offset from top edge
-    -   `options.width` **[number][8]** width of region to extract
-    -   `options.height` **[number][8]** height of region to extract
+*   `options` **[Object][9]** describes the region to extract using integral pixel values
+
+    *   `options.left` **[number][8]** zero-indexed offset from left edge
+    *   `options.top` **[number][8]** zero-indexed offset from top edge
+    *   `options.width` **[number][8]** width of region to extract
+    *   `options.height` **[number][8]** height of region to extract
 
 ### Examples
 
@@ -210,7 +229,7 @@ sharp(input)
   });
 ```
 
--   Throws **[Error][13]** Invalid parameters
+*   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 
@@ -224,10 +243,11 @@ will contain `trimOffsetLeft` and `trimOffsetTop` properties.
 
 ### Parameters
 
--   `threshold` **[number][8]** the allowed difference from the top-left pixel, a number greater than zero. (optional, default `10`)
+*   `threshold` **[number][8]** the allowed difference from the top-left pixel, a number greater than zero. (optional, default `10`)
 
+<!---->
 
--   Throws **[Error][13]** Invalid parameters
+*   Throws **[Error][13]** Invalid parameters
 
 Returns **Sharp** 
 

docs/api-utility.md

@@ -52,19 +52,31 @@ An Object containing the version numbers of libvips and its dependencies.
 console.log(sharp.versions);
 ```
 
+## vendor
+
+An Object containing the platform and architecture
+of the current and installed vendored binaries.
+
+### Examples
+
+```javascript
+console.log(sharp.vendor);
+```
+
 ## cache
 
-Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
+Gets or, when options are provided, sets the limits of *libvips'* operation cache.
 Existing entries in the cache will be trimmed after any change in limits.
 This method always returns cache statistics,
 useful for determining how much working memory is required for a particular task.
 
 ### Parameters
 
--   `options` **([Object][1] \| [boolean][10])** Object with the following attributes, or boolean where true uses default cache settings and false removes all caching (optional, default `true`)
-    -   `options.memory` **[number][11]** is the maximum memory in MB to use for this cache (optional, default `50`)
-    -   `options.files` **[number][11]** is the maximum number of files to hold open (optional, default `20`)
-    -   `options.items` **[number][11]** is the maximum number of operations to cache (optional, default `100`)
+*   `options` **([Object][1] | [boolean][10])** Object with the following attributes, or boolean where true uses default cache settings and false removes all caching (optional, default `true`)
+
+    *   `options.memory` **[number][11]** is the maximum memory in MB to use for this cache (optional, default `50`)
+    *   `options.files` **[number][11]** is the maximum number of files to hold open (optional, default `20`)
+    *   `options.items` **[number][11]** is the maximum number of operations to cache (optional, default `100`)
 
 ### Examples
 
@@ -83,7 +95,7 @@ Returns **[Object][1]**
 ## concurrency
 
 Gets or, when a concurrency is provided, sets
-the number of threads _libvips'_ should create to process each image.
+the number of threads *libvips'* should create to process each image.
 
 The default value is the number of CPU cores,
 except when using glibc-based Linux without jemalloc,
@@ -98,7 +110,7 @@ This method always returns the current concurrency.
 
 ### Parameters
 
--   `concurrency` **[number][11]?** 
+*   `concurrency` **[number][11]?** 
 
 ### Examples
 
@@ -114,8 +126,8 @@ Returns **[number][11]** concurrency
 
 An EventEmitter that emits a `change` event when a task is either:
 
--   queued, waiting for _libuv_ to provide a worker thread
--   complete
+*   queued, waiting for *libuv* to provide a worker thread
+*   complete
 
 ### Examples
 
@@ -129,8 +141,8 @@ sharp.queue.on('change', function(queueLength) {
 
 Provides access to internal task counters.
 
--   queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
--   process is the number of resize tasks currently being processed.
+*   queue is the number of tasks this module has queued waiting for *libuv* to provide a worker thread from its pool.
+*   process is the number of resize tasks currently being processed.
 
 ### Examples
 
@@ -150,7 +162,7 @@ by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM N
 
 ### Parameters
 
--   `simd` **[boolean][10]**  (optional, default `true`)
+*   `simd` **[boolean][10]**  (optional, default `true`)
 
 ### Examples
 

docs/changelog.md

@@ -1,9 +1,201 @@
 # Changelog
 
+## v0.30 - *dresser*
+
+Requires libvips v8.12.2
+
+### v0.30.0 - 1st February 2022
+
+* Add support for GIF output to prebuilt binaries.
+
+* Reduce minimum Linux ARM64v8 glibc requirement to 2.17.
+
+* Verify prebuilt binaries with a Subresource Integrity check.
+
+* Standardise WebP `effort` option name, deprecate `reductionEffort`.
+
+* Standardise HEIF `effort` option name, deprecate `speed`.
+
+* Add support for IIIF v3 tile-based output.
+
+* Expose control over CPU effort for palette-based PNG output.
+  [#2541](https://github.com/lovell/sharp/issues/2541)
+
+* Improve animated (multi-page) image resize and extract.
+  [#2789](https://github.com/lovell/sharp/pull/2789)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Expose platform and architecture of vendored binaries as `sharp.vendor`.
+  [#2928](https://github.com/lovell/sharp/issues/2928)
+
+* Ensure 16-bit PNG output uses correct bitdepth.
+  [#2958](https://github.com/lovell/sharp/pull/2958)
+  [@gforge](https://github.com/gforge)
+
+* Properly emit close events for duplex streams.
+  [#2976](https://github.com/lovell/sharp/pull/2976)
+  [@driannaude](https://github.com/driannaude)
+
+* Expose `unlimited` option for SVG and PNG input, switches off safety features.
+  [#2984](https://github.com/lovell/sharp/issues/2984)
+
+* Add `withoutReduction` option to resize operation.
+  [#3006](https://github.com/lovell/sharp/pull/3006)
+  [@christopherbradleybanks](https://github.com/christopherbradleybanks)
+
+* Add `resolutionUnit` as `tiff` option and expose in metadata.
+  [#3023](https://github.com/lovell/sharp/pull/3023)
+  [@ompal-sisodiya](https://github.com/ompal-sisodiya)
+
+* Ensure rotate-then-extract works with EXIF mirroring.
+  [#3024](https://github.com/lovell/sharp/issues/3024)
+
+## v0.29 - *circle*
+
+Requires libvips v8.11.3
+
+### v0.29.3 - 14th November 2021
+
+* Ensure correct dimensions when containing image resized to 1px.
+  [#2951](https://github.com/lovell/sharp/issues/2951)
+
+* Impute TIFF `xres`/`yres` from `density` provided to `withMetadata`.
+  [#2952](https://github.com/lovell/sharp/pull/2952)
+  [@mbklein](https://github.com/mbklein)
+
+### v0.29.2 - 21st October 2021
+
+* Add `timeout` function to limit processing time.
+
+* Ensure `sharp.versions` is populated from vendored libvips.
+
+* Remove animation properties from single page images.
+  [#2890](https://github.com/lovell/sharp/issues/2890)
+
+* Allow use of 'tif' to select TIFF output.
+  [#2893](https://github.com/lovell/sharp/pull/2893)
+  [@erf](https://github.com/erf)
+
+* Improve error message on Windows for version conflict.
+  [#2918](https://github.com/lovell/sharp/pull/2918)
+  [@dkrnl](https://github.com/dkrnl)
+
+* Throw error rather than exit when invalid binaries detected.
+  [#2931](https://github.com/lovell/sharp/issues/2931)
+
+### v0.29.1 - 7th September 2021
+
+* Add `lightness` option to `modulate` operation.
+  [#2846](https://github.com/lovell/sharp/pull/2846)
+
+* Ensure correct PNG bitdepth is set based on number of colours.
+  [#2855](https://github.com/lovell/sharp/issues/2855)
+
+* Ensure background is always premultiplied when compositing.
+  [#2858](https://github.com/lovell/sharp/issues/2858)
+
+* Ensure images with P3 profiles retain full gamut.
+  [#2862](https://github.com/lovell/sharp/issues/2862)
+
+* Add support for libvips compiled with OpenJPEG.
+  [#2868](https://github.com/lovell/sharp/pull/2868)
+
+* Remove unsupported animation properties from AVIF output.
+  [#2870](https://github.com/lovell/sharp/issues/2870)
+
+* Resolve paths before comparing input/output filenames.
+  [#2878](https://github.com/lovell/sharp/pull/2878)
+  [@rexxars](https://github.com/rexxars)
+
+* Allow use of speed 9 (fastest) for HEIF encoding.
+  [#2879](https://github.com/lovell/sharp/pull/2879)
+  [@rexxars](https://github.com/rexxars)
+
+### v0.29.0 - 17th August 2021
+
+* Drop support for Node.js 10, now requires Node.js >= 12.13.0.
+
+* Add `background` property to PNG and GIF image metadata.
+
+* Add `compression` property to HEIF image metadata.
+  [#2504](https://github.com/lovell/sharp/issues/2504)
+
+* AVIF encoding now defaults to `4:4:4` chroma subsampling.
+  [#2562](https://github.com/lovell/sharp/issues/2562)
+
+* Allow multiple platform-arch binaries in same `node_modules` installation tree.
+  [#2575](https://github.com/lovell/sharp/issues/2575)
+
+* Default to single-channel `b-w` space when `extractChannel` is used.
+  [#2658](https://github.com/lovell/sharp/issues/2658)
+
+* Allow installation directory to contain spaces (regression in v0.26.0).
+  [#2777](https://github.com/lovell/sharp/issues/2777)
+
+* Add `pipelineColourspace` operator to set the processing space.
+  [#2704](https://github.com/lovell/sharp/pull/2704)
+  [@Daiz](https://github.com/Daiz)
+
+* Allow bit depth to be set when using raw input and output.
+  [#2762](https://github.com/lovell/sharp/pull/2762)
+  [@mart-jansink](https://github.com/mart-jansink)
+
+* Allow `negate` to act only on non-alpha channels.
+  [#2808](https://github.com/lovell/sharp/pull/2808)
+  [@rexxars](https://github.com/rexxars)
+
 ## v0.28 - *bijou*
 
 Requires libvips v8.10.6
 
+### v0.28.3 - 24th May 2021
+
+* Ensure presence of libvips, vendored or global, before invoking node-gyp.
+
+* Skip shrink-on-load for multi-page WebP.
+  [#2714](https://github.com/lovell/sharp/issues/2714)
+
+* Add contrast limiting adaptive histogram equalization (CLAHE) operator.
+  [#2726](https://github.com/lovell/sharp/pull/2726)
+  [@baparham](https://github.com/baparham)
+
+### v0.28.2 - 10th May 2021
+
+* Allow `withMetadata` to set `density`.
+  [#967](https://github.com/lovell/sharp/issues/967)
+
+* Skip shrink-on-load where one dimension <4px.
+  [#2653](https://github.com/lovell/sharp/issues/2653)
+
+* Allow escaped proxy credentials.
+  [#2664](https://github.com/lovell/sharp/pull/2664)
+  [@msalettes](https://github.com/msalettes)
+
+* Add `premultiplied` flag for raw pixel data input.
+  [#2685](https://github.com/lovell/sharp/pull/2685)
+  [@mnutt](https://github.com/mnutt)
+
+* Detect empty input and throw a helpful error.
+  [#2687](https://github.com/lovell/sharp/pull/2687)
+  [@JakobJingleheimer](https://github.com/JakobJingleheimer)
+
+* Add install-time flag to skip version compatibility checks.
+  [#2692](https://github.com/lovell/sharp/pull/2692)
+  [@xemle](https://github.com/xemle)
+
+### v0.28.1 - 5th April 2021
+
+* Ensure all installation errors are logged with a more obvious prefix.
+
+* Allow `withMetadata` to set and update EXIF metadata.
+  [#650](https://github.com/lovell/sharp/issues/650)
+
+* Add support for OME-TIFF Sub Image File Directories (subIFD).
+  [#2557](https://github.com/lovell/sharp/issues/2557)
+
+* Allow `ensureAlpha` to set the alpha transparency level.
+  [#2634](https://github.com/lovell/sharp/issues/2634)
+
 ### v0.28.0 - 29th March 2021
 
 * Prebuilt binaries now include mozjpeg and libimagequant (BSD 2-Clause).

docs/firebase.json

@@ -6,7 +6,6 @@
       ".*",
       "build.js",
       "firebase.json",
-      "*.md",
       "image/**",
       "search-index/**"
     ],
@@ -14,10 +13,9 @@
       {
         "source": "**",
         "headers": [
-          {
-            "key": "Cache-Control",
-            "value": "max-age=86400"
-          }
+          { "key": "Cache-Control", "value": "max-age=86400" },
+          { "key": "X-Content-Type-Options", "value": "nosniff" },
+          { "key": "X-Frame-Options", "value": "SAMEORIGIN" }
         ]
       }
     ],

docs/humans.txt

@@ -209,3 +209,30 @@ GitHub: https://github.com/beig
 
 Name: Florian Busch
 GitHub: https://github.com/florian-busch
+
+Name: Matthieu Salettes
+GitHub: https://github.com/msalettes
+
+Name: Taneli Vatanen
+GitHub: https://github.com/Daiz
+
+Name: Mart Jansink
+GitHub: https://github.com/mart-jansink
+
+Name: Tenpi
+GitHub: https://github.com/Tenpi
+
+Name: Zaruike
+GitHub: https://github.com/Zaruike
+
+Name: Erlend F
+GitHub: https://github.com/erf
+
+Name: Drian Naude
+GitHub: https://github.com/driannaude
+
+Name: Max Gordon
+GitHub: https://github.com/gforge
+
+Name: Chris Banks
+GitHub: https://github.com/christopherbradleybanks

docs/install.md

@@ -10,37 +10,37 @@ yarn add sharp
 
 ## Prerequisites
 
-* Node.js v10+
+* Node.js >= 12.13.0
 
 ## Prebuilt binaries
 
-Ready-compiled sharp and libvips binaries are provided for use with
-Node.js v10+ on the most common platforms:
+Ready-compiled sharp and libvips binaries are provided for use on the most common platforms:
 
 * macOS x64 (>= 10.13)
-* Linux x64 (glibc >= 2.17, musl >= 1.1.24)
-* Linux ARM64 (glibc >= 2.29, musl >= 1.1.24)
+* macOS ARM64
+* Linux x64 (glibc >= 2.17, musl >= 1.1.24, CPU with SSE4.2)
+* Linux ARM64 (glibc >= 2.17, musl >= 1.1.24)
 * Windows x64
 * Windows x86
 
-An ~7.5MB tarball containing libvips and its most commonly used dependencies
-is downloaded via HTTPS and stored within `node_modules/sharp/vendor` during `npm install`.
+A ~7MB tarball containing libvips and its most commonly used dependencies
+is downloaded via HTTPS, verified via Subresource Integrity
+and decompressed into `node_modules/sharp/vendor` during `npm install`.
 
 This provides support for the
-JPEG, PNG, WebP, AVIF, TIFF, GIF (input) and SVG (input) image formats.
+JPEG, PNG, WebP, AVIF, TIFF, GIF and SVG (input) image formats.
 
 The following platforms have prebuilt libvips but not sharp:
 
-* macOS ARM64
-* Linux ARMv6
 * Linux ARMv7 (glibc >= 2.28)
+* Linux ARMv6 (glibc >= 2.28)
 * Windows ARM64
 
 The following platforms require compilation of both libvips and sharp from source:
 
 * Linux x86
-* Linux x64 (glibc <= 2.16, includes RHEL/CentOS 6)
-* Linux ARM64 (glibc <= 2.28)
+* Linux ARMv7 (glibc <= 2.27, musl)
+* Linux ARMv6 (glibc <= 2.27, musl)
 * Linux PowerPC
 * FreeBSD
 * OpenBSD
@@ -49,10 +49,11 @@ The following platforms require compilation of both libvips and sharp from sourc
 
 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.
+See the [cross-platform](#cross-platform) section if this is not the case.
 
 When using npm v6 or earlier, the `npm install --unsafe-perm` flag must be used when installing as `root` or a `sudo` user.
 
-When using npm v7, the user running `npm install` must own the directory it is run in.
+When using npm v7 or later, the user running `npm install` must own the directory it is run in.
 
 The `npm install --ignore-scripts=false` flag must be used when `npm` has been configured to ignore installation scripts.
 
@@ -60,15 +61,34 @@ Check the output of running `npm install --verbose sharp` for useful error messa
 
 ## Apple M1
 
-Prebuilt libvips binaries are provided for macOS on ARM64 (since sharp v0.28.0).
+Prebuilt sharp and libvips binaries have been provided for macOS on ARM64 since sharp v0.29.0.
 
-During `npm install` sharp will be built locally,
-which requires Xcode and Python - see
-[building from source](#building-from-source).
+## Cross-platform
 
-When this new ARM64 CPU is made freely available
-to open source projects via a CI service
-then prebuilt sharp binaries can also be provided.
+At `npm install` time, prebuilt binaries are automatically selected for the
+current OS platform and CPU architecture, where available.
+
+The target platform and/or architecture can be manually selected using the following flags.
+
+```sh
+npm install --platform=... --arch=... --arm-version=... sharp
+```
+
+* `--platform`: one of `linux`, `linuxmusl`, `darwin` or `win32`.
+* `--arch`: one of `x64`, `ia32`, `arm` or `arm64`.
+* `--arm-version`: one of `6`, `7` or `8` (`arm` defaults to `6`, `arm64` defaults to `8`).
+* `--sharp-install-force`: skip version compatibility and Subresource Integrity checks.
+
+These values can also be set via environment variables,
+`npm_config_platform`, `npm_config_arch`, `npm_config_arm_version`
+and `SHARP_INSTALL_FORCE` respectively.
+
+For example, if the target machine has a 64-bit ARM CPU and is running Alpine Linux,
+use the following flags:
+
+```sh
+npm install --arch=arm64 --platform=linuxmusl sharp
+```
 
 ## Custom libvips
 
@@ -102,38 +122,38 @@ To install the prebuilt sharp binaries from a custom URL,
 set the `sharp_binary_host` npm config option
 or the `npm_config_sharp_binary_host` environment variable.
 
+To install the prebuilt sharp binaries from a directory on the local filesystem,
+set the `sharp_local_prebuilds` npm config option
+or the `npm_config_sharp_local_prebuilds` environment variable.
+
 To install the prebuilt libvips binaries from a custom URL,
 set the `sharp_libvips_binary_host` npm config option
 or the `npm_config_sharp_libvips_binary_host` environment variable.
 
-The version subpath and file name are appended to these. There should be tarballs available
-that are compressed with both gzip and Brotli, as the format downloaded will vary depending
-on whether the user's version of Node supports Brotli decompression (Node.js v10.16.0+)
-
+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.br` or 
-`https://hostname/path/v1.2.3/libvips-1.2.3-platform-arch.tar.gz`.
+`https://hostname/path/v1.2.3/libvips-1.2.3-platform-arch.tar.br`.
 
 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.
+A mirror site based in China, provided by Alibaba, contains binaries for both sharp and libvips.
 
 To use this either set the following configuration:
 
 ```sh
-npm config set sharp_binary_host "https://npm.taobao.org/mirrors/sharp"
-npm config set sharp_libvips_binary_host "https://npm.taobao.org/mirrors/sharp-libvips"
+npm config set sharp_binary_host "https://npmmirror.com/mirrors/sharp"
+npm config set sharp_libvips_binary_host "https://npmmirror.com/mirrors/sharp-libvips"
 npm install sharp
 ```
 
 or set the following environment variables:
 
 ```sh
-npm_config_sharp_binary_host="https://npm.taobao.org/mirrors/sharp" \
-  npm_config_sharp_libvips_binary_host="https://npm.taobao.org/mirrors/sharp-libvips" \
+npm_config_sharp_binary_host="https://npmmirror.com/mirrors/sharp" \
+  npm_config_sharp_libvips_binary_host="https://npmmirror.com/mirrors/sharp-libvips" \
   npm install sharp
 ```
 
@@ -178,34 +198,18 @@ to `false` when using the `yarn` package manager.
 
 ## AWS Lambda
 
-Set the Lambda runtime to `nodejs12.x`.
-
-The binaries in the `node_modules` directory of the
+The `node_modules` directory of the
 [deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-package.html)
-must be for the Linux x64 platform.
+must include binaries for the Linux x64 platform.
 
 When building your deployment package on machines other than Linux x64 (glibc),
-run the following commands:
+run the following additional command after `npm install`:
 
-macOS:
 ```sh
-rm -rf node_modules/sharp
+npm install
 SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install --arch=x64 --platform=linux sharp
 ```
 
-Windows:
-```sh
-rmdir /s /q node_modules/sharp
-npm install --arch=x64 --platform=linux sharp
-```
-
-Alternatively a Docker container closely matching the Lambda runtime can be used:
-
-```sh
-rm -rf node_modules/sharp
-docker run -v "$PWD":/var/task lambci/lambda:build-nodejs12.x npm install sharp
-```
-
 To get the best performance select the largest memory available.
 A 1536 MB function provides ~12x more CPU time than a 128 MB function.
 

docs/performance.md

@@ -5,10 +5,12 @@ A test to benchmark the performance of this module relative to alternatives.
 ## The contenders
 
 * [jimp](https://www.npmjs.com/package/jimp) v0.16.1 - Image processing in pure JavaScript. Provides bicubic interpolation.
-* [mapnik](https://www.npmjs.org/package/mapnik) v4.5.6 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
+* [mapnik](https://www.npmjs.org/package/mapnik) v4.5.9 - Whilst primarily a map renderer, Mapnik contains bitmap image utilities.
 * [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
 * [gm](https://www.npmjs.com/package/gm) v1.23.1 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.28.0 / libvips v8.10.6 - Caching within libvips disabled to ensure a fair comparison.
+* [@squoosh/lib](https://www.npmjs.com/package/@squoosh/lib) v0.4.0 - Image libraries transpiled to WebAssembly, includes GPLv3 code.
+* [@squoosh/cli](https://www.npmjs.com/package/@squoosh/cli) v0.7.2 - Command line wrapper around `@squoosh/lib`, avoids GPLv3 by spawning process.
+* sharp v0.30.0 / libvips v8.12.2 - Caching within libvips disabled to ensure a fair comparison.
 
 ## The task
 
@@ -19,21 +21,23 @@ then compress to JPEG at a "quality" setting of 80.
 ## Test environment
 
 * AWS EC2 eu-west-1 [c5ad.xlarge](https://aws.amazon.com/ec2/instance-types/c5/) (4x AMD EPYC 7R32)
-* Ubuntu 20.10 (ami-03f10415e8b0bfb86)
-* Node.js v14.16.0
+* Ubuntu 21.10 (ami-0258eeb71ddf238b3)
+* Node.js 16.13.2
 
 ## Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp               | buffer | buffer |    0.78 |      1.0 |
-| mapnik             | buffer | buffer |    3.39 |      4.3 |
-| gm                 | buffer | buffer |    7.84 |     10.1 |
-| gm                 | file   | file   |    9.24 |     11.8 |
-| imagemagick        | file   | file   |    9.37 |     12.0 |
-| sharp              | stream | stream |   26.84 |     34.4 |
-| sharp              | file   | file   |   29.76 |     38.2 |
-| sharp              | buffer | buffer |   31.60 |     40.5 |
+| jimp               | buffer | buffer |    0.84 |      1.0 |
+| squoosh-cli        | file   | file   |    1.08 |      1.3 |
+| squoosh-lib        | buffer | buffer |    1.85 |      2.2 |
+| mapnik             | buffer | buffer |    3.45 |      4.1 |
+| gm                 | buffer | buffer |    8.60 |     10.2 |
+| gm                 | file   | file   |    8.66 |     10.3 |
+| imagemagick        | file   | file   |    8.79 |     10.5 |
+| sharp              | stream | stream |   28.90 |     34.4 |
+| sharp              | file   | file   |   30.08 |     35.8 |
+| sharp              | buffer | buffer |   30.42 |     36.2 |
 
 Greater libvips performance can be expected with caching enabled (default)
 and using 8+ core machines, especially those with larger L1/L2 CPU caches.

docs/search-index/build.js

@@ -2,7 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { extractDescription, extractKeywords } = require('./extract');
+const { extractDescription, extractKeywords, extractParameters } = require('./extract');
 
 const searchIndex = [];
 
@@ -37,18 +37,19 @@ for (const match of matches) {
 ].forEach((section) => {
   const contents = fs.readFileSync(path.join(__dirname, '..', `api-${section}.md`), 'utf8');
   const matches = contents.matchAll(
-    /\n## (?<title>[A-Za-z]+)\n\n(?<firstparagraph>.+?)\n\n/gs
+    /\n## (?<title>[A-Za-z]+)\n\n(?<firstparagraph>.+?)\n\n(?<parameters>### Parameters.+?Returns)?/gs
   );
   for (const match of matches) {
-    const { title, firstparagraph } = match.groups;
+    const { title, firstparagraph, parameters } = match.groups;
     const description = firstparagraph.startsWith('###')
       ? 'Constructor'
       : extractDescription(firstparagraph);
+    const parameterNames = parameters ? extractParameters(parameters) : '';
 
     searchIndex.push({
       t: title,
       d: description,
-      k: extractKeywords(`${title} ${description}`),
+      k: extractKeywords(`${title} ${description} ${parameterNames}`),
       l: `/api-${section}#${title.toLowerCase()}`
     });
   }

docs/search-index/extract.js

@@ -4,6 +4,7 @@ const stopWords = require('./stop-words');
 
 const extractDescription = (str) =>
   str
+    .replace(/### Examples.*/sg, '')
     .replace(/\(http[^)]+/g, '')
     .replace(/\s+/g, ' ')
     .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
@@ -11,6 +12,11 @@ const extractDescription = (str) =>
     .substr(0, 180)
     .trim();
 
+const extractParameters = (str) =>
+  [...str.matchAll(/options\.(?<name>[^.`]+)/gs)]
+    .map((match) => match.groups.name)
+    .join(' ');
+
 const extractKeywords = (str) =>
   [
     ...new Set(
@@ -21,4 +27,4 @@ const extractKeywords = (str) =>
     )
   ].join(' ');
 
-module.exports = { extractDescription, extractKeywords };
+module.exports = { extractDescription, extractKeywords, extractParameters };

docs/search-index/stop-words.js

@@ -17,15 +17,22 @@ module.exports = [
   'before',
   'both',
   'call',
+  'callback',
   'can',
   'containing',
+  'contains',
+  'current',
+  'date',
   'default',
   'does',
   'each',
   'either',
   'ensure',
+  'entirely',
   'etc',
   'every',
+  'except',
+  'following',
   'for',
   'from',
   'get',
@@ -35,10 +42,13 @@ module.exports = [
   'have',
   'how',
   'image',
+  'implies',
   'involve',
   'its',
+  'last',
   'least',
   'lots',
+  'make',
   'may',
   'more',
   'most',
@@ -49,39 +59,52 @@ module.exports = [
   'occur',
   'occurs',
   'options',
+  'other',
+  'out',
   'over',
   'perform',
   'performs',
+  'produce',
   'provide',
   'provided',
   'ready',
+  'requires',
+  'returned',
   'same',
   'see',
   'set',
   'sets',
   'should',
   'since',
+  'site',
+  'specified',
   'spelling',
   'such',
   'support',
   'supported',
   'sure',
   'take',
+  'task',
+  'than',
   'that',
   'the',
   'their',
+  'then',
   'there',
   'therefore',
   'these',
   'this',
   'under',
   'unless',
+  'unmaintained',
+  'unsuitable',
   'until',
   'use',
   'used',
   'using',
   'value',
   'values',
+  'were',
   'when',
   'which',
   'while',

install/can-compile.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const libvips = require('../lib/libvips');
+
+try {
+  if (!(libvips.useGlobalLibvips() || libvips.hasVendoredLibvips())) {
+    process.exitCode = 1;
+  }
+} catch (err) {
+  process.exitCode = 1;
+}

install/dll-copy.js

@@ -4,19 +4,19 @@ const fs = require('fs');
 const path = require('path');
 
 const libvips = require('../lib/libvips');
+const platform = require('../lib/platform');
 
 const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
 
-const platform = process.env.npm_config_platform || process.platform;
-if (platform === 'win32') {
-  const buildDir = path.join(__dirname, '..', 'build');
-  const buildReleaseDir = path.join(buildDir, 'Release');
+const platformAndArch = platform();
+
+if (platformAndArch.startsWith('win32')) {
+  const buildReleaseDir = path.join(__dirname, '..', 'build', 'Release');
   libvips.log(`Creating ${buildReleaseDir}`);
   try {
-    libvips.mkdirSync(buildDir);
     libvips.mkdirSync(buildReleaseDir);
   } catch (err) {}
-  const vendorLibDir = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, 'lib');
+  const vendorLibDir = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, platformAndArch, 'lib');
   libvips.log(`Copying DLLs from ${vendorLibDir} to ${buildReleaseDir}`);
   try {
     fs

install/libvips.js

@@ -5,9 +5,11 @@ const os = require('os');
 const path = require('path');
 const stream = require('stream');
 const zlib = require('zlib');
+const { createHash } = require('crypto');
 
 const detectLibc = require('detect-libc');
-const semver = require('semver');
+const semverLessThan = require('semver/functions/lt');
+const semverSatisfies = require('semver/functions/satisfies');
 const simpleGet = require('simple-get');
 const tarFs = require('tar-fs');
 
@@ -17,12 +19,13 @@ const platform = require('../lib/platform');
 
 const minimumGlibcVersionByArch = {
   arm: '2.28',
-  arm64: '2.29',
+  arm64: '2.17',
   x64: '2.17'
 };
 
 const hasSharpPrebuild = [
   'darwin-x64',
+  'darwin-arm64',
   'linux-arm64',
   'linux-x64',
   'linuxmusl-x64',
@@ -34,22 +37,54 @@ const hasSharpPrebuild = [
 const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
 const distHost = process.env.npm_config_sharp_libvips_binary_host || 'https://github.com/lovell/sharp-libvips/releases/download';
 const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `${distHost}/v${minimumLibvipsVersionLabelled}/`;
-const supportsBrotli = ('BrotliDecompress' in zlib);
+const installationForced = !!(process.env.npm_config_sharp_install_force || process.env.SHARP_INSTALL_FORCE);
 
 const fail = function (err) {
   libvips.log(err);
   if (err.code === 'EACCES') {
     libvips.log('Are you trying to install as a root or sudo user? Try again with the --unsafe-perm flag');
   }
-  libvips.log('Attempting to build from source via node-gyp but this may fail due to the above error');
   libvips.log('Please see https://sharp.pixelplumbing.com/install for required dependencies');
   process.exit(1);
 };
 
+const handleError = function (err) {
+  if (installationForced) {
+    libvips.log(`Installation warning: ${err.message}`);
+  } else {
+    throw err;
+  }
+};
+
+const verifyIntegrity = function (platformAndArch) {
+  const expected = libvips.integrity(platformAndArch);
+  if (installationForced || !expected) {
+    libvips.log(`Integrity check skipped for ${platformAndArch}`);
+    return new stream.PassThrough();
+  }
+  const hash = createHash('sha512');
+  return new stream.Transform({
+    transform: function (chunk, _encoding, done) {
+      hash.update(chunk);
+      done(null, chunk);
+    },
+    flush: function (done) {
+      const digest = `sha512-${hash.digest('base64')}`;
+      if (expected !== digest) {
+        libvips.removeVendoredLibvips();
+        libvips.log(`Integrity expected: ${expected}`);
+        libvips.log(`Integrity received: ${digest}`);
+        done(new Error(`Integrity check failed for ${platformAndArch}`));
+      } else {
+        libvips.log(`Integrity check passed for ${platformAndArch}`);
+        done();
+      }
+    }
+  });
+};
+
 const extractTarball = function (tarPath, platformAndArch) {
-  const vendorPath = path.join(__dirname, '..', 'vendor');
-  libvips.mkdirSync(vendorPath);
-  const versionedVendorPath = path.join(vendorPath, minimumLibvipsVersion);
+  const versionedVendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, platformAndArch);
   libvips.mkdirSync(versionedVendorPath);
 
   const ignoreVendorInclude = hasSharpPrebuild.includes(platformAndArch) && !process.env.npm_config_build_from_source;
@@ -59,7 +94,8 @@ const extractTarball = function (tarPath, platformAndArch) {
 
   stream.pipeline(
     fs.createReadStream(tarPath),
-    supportsBrotli ? new zlib.BrotliDecompress() : new zlib.Gunzip(),
+    verifyIntegrity(platformAndArch),
+    new zlib.BrotliDecompress(),
     tarFs.extract(versionedVendorPath, { ignore }),
     function (err) {
       if (err) {
@@ -95,26 +131,27 @@ try {
     if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
       throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
-    if (detectLibc.family === detectLibc.GLIBC && detectLibc.version) {
-      if (semver.lt(`${detectLibc.version}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
-        throw new Error(`Use with glibc ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+    // Linux libc version check
+    const libcFamily = detectLibc.familySync();
+    const libcVersion = detectLibc.versionSync();
+    if (libcFamily === detectLibc.GLIBC && libcVersion && minimumGlibcVersionByArch[arch]) {
+      if (semverLessThan(`${libcVersion}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
+        handleError(new Error(`Use with glibc ${libcVersion} requires manual installation of libvips >= ${minimumLibvipsVersion}`));
       }
     }
-    if (detectLibc.family === detectLibc.MUSL && detectLibc.version) {
-      if (semver.lt(detectLibc.version, '1.1.24')) {
-        throw new Error(`Use with musl ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
+    if (libcFamily === detectLibc.MUSL && libcVersion) {
+      if (semverLessThan(libcVersion, '1.1.24')) {
+        handleError(new Error(`Use with musl ${libcVersion} requires manual installation of libvips >= ${minimumLibvipsVersion}`));
       }
     }
-
+    // Node.js minimum version check
     const supportedNodeVersion = process.env.npm_package_engines_node || require('../package.json').engines.node;
-    if (!semver.satisfies(process.versions.node, supportedNodeVersion)) {
-      throw new Error(`Expected Node.js version ${supportedNodeVersion} but found ${process.versions.node}`);
+    if (!semverSatisfies(process.versions.node, supportedNodeVersion)) {
+      handleError(new Error(`Expected Node.js version ${supportedNodeVersion} but found ${process.versions.node}`));
     }
 
-    const extension = supportsBrotli ? 'br' : 'gz';
-
     // Download to per-process temporary file
-    const tarFilename = ['libvips', minimumLibvipsVersion, platformAndArch].join('-') + '.tar.' + extension;
+    const tarFilename = ['libvips', minimumLibvipsVersionLabelled, platformAndArch].join('-') + '.tar.br';
     const tarPathCache = path.join(libvips.cachePath(), tarFilename);
     if (fs.existsSync(tarPathCache)) {
       libvips.log(`Using cached ${tarPathCache}`);
@@ -145,7 +182,9 @@ try {
           tmpFileStream
             .on('error', function (err) {
               // Clean up temporary file
-              fs.unlinkSync(tarPathTemp);
+              try {
+                fs.unlinkSync(tarPathTemp);
+              } catch (e) {}
               fail(err);
             })
             .on('close', function () {
@@ -157,7 +196,7 @@ try {
                 fs.copyFileSync(tarPathTemp, tarPathCache);
                 fs.unlinkSync(tarPathTemp);
               }
-              extractTarball(tarPathCache);
+              extractTarball(tarPathCache, platformAndArch);
             });
         }
       });

lib/agent.js

@@ -25,7 +25,7 @@ module.exports = function () {
       ? tunnelAgent.httpsOverHttps
       : tunnelAgent.httpsOverHttp;
     const proxyAuth = proxy.username && proxy.password
-      ? `${proxy.username}:${proxy.password}`
+      ? `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`
       : null;
     return tunnel({
       proxy: {

lib/channel.js

@@ -15,6 +15,8 @@ const bool = {
 /**
  * Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
  *
+ * See also {@link /api-operation#flatten|flatten}.
+ *
  * @example
  * sharp('rgba.png')
  *   .removeAlpha()
@@ -30,21 +32,39 @@ function removeAlpha () {
 }
 
 /**
- * Ensure alpha channel, if missing. The added alpha channel will be fully opaque. This is a no-op if the image already has an alpha channel.
+ * Ensure the output image has an alpha transparency channel.
+ * If missing, the added alpha channel will have the specified
+ * transparency level, defaulting to fully-opaque (1).
+ * This is a no-op if the image already has an alpha channel.
  *
  * @since 0.21.2
  *
  * @example
- * sharp('rgb.jpg')
+ * // rgba.png will be a 4 channel image with a fully-opaque alpha channel
+ * await sharp('rgb.jpg')
  *   .ensureAlpha()
- *   .toFile('rgba.png', function(err, info) {
- *     // rgba.png is a 4 channel image with a fully opaque alpha channel
- *   });
+ *   .toFile('rgba.png')
  *
+ * @example
+ * // rgba is a 4 channel image with a fully-transparent alpha channel
+ * const rgba = await sharp(rgb)
+ *   .ensureAlpha(0)
+ *   .toBuffer();
+ *
+ * @param {number} [alpha=1] - alpha transparency level (0=fully-transparent, 1=fully-opaque)
  * @returns {Sharp}
+ * @throws {Error} Invalid alpha transparency level
  */
-function ensureAlpha () {
-  this.options.ensureAlpha = true;
+function ensureAlpha (alpha) {
+  if (is.defined(alpha)) {
+    if (is.number(alpha) && is.inRange(alpha, 0, 1)) {
+      this.options.ensureAlpha = alpha;
+    } else {
+      throw is.invalidParameterError('alpha', 'number between 0 and 1', alpha);
+    }
+  } else {
+    this.options.ensureAlpha = 1;
+  }
   return this;
 }
 
@@ -52,13 +72,17 @@ function ensureAlpha () {
  * Extract a single channel from a multi-channel image.
  *
  * @example
- * sharp(input)
+ * // green.jpg is a greyscale image containing the green channel of the input
+ * await sharp(input)
  *   .extractChannel('green')
- *   .toColourspace('b-w')
- *   .toFile('green.jpg', function(err, info) {
- *     // info.channels === 1
- *     // green.jpg is a greyscale image containing the green channel of the input
- *    });
+ *   .toFile('green.jpg');
+ *
+ * @example
+ * // red1 is the red value of the first pixel, red2 the second pixel etc.
+ * const [red1, red2, ...] = await sharp(input)
+ *   .extractChannel(0)
+ *   .raw()
+ *   .toBuffer();
  *
  * @param {number|string} channel - zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
  * @returns {Sharp}
@@ -74,7 +98,7 @@ function extractChannel (channel) {
   } else {
     throw is.invalidParameterError('channel', 'integer or one of: red, green, blue, alpha', channel);
   }
-  return this;
+  return this.toColourspace('b-w');
 }
 
 /**

lib/colour.js

@@ -54,6 +54,45 @@ function grayscale (grayscale) {
   return this.greyscale(grayscale);
 }
 
+/**
+ * Set the pipeline colourspace.
+ *
+ * The input image will be converted to the provided colourspace at the start of the pipeline.
+ * All operations will use this colourspace before converting to the output colourspace, as defined by {@link toColourspace}.
+ *
+ * This feature is experimental and has not yet been fully-tested with all operations.
+ *
+ * @since 0.29.0
+ *
+ * @example
+ * // Run pipeline in 16 bits per channel RGB while converting final result to 8 bits per channel sRGB.
+ * await sharp(input)
+ *  .pipelineColourspace('rgb16')
+ *  .toColourspace('srgb')
+ *  .toFile('16bpc-pipeline-to-8bpc-output.png')
+ *
+ * @param {string} [colourspace] - pipeline colourspace e.g. `rgb16`, `scrgb`, `lab`, `grey16` [...](https://github.com/libvips/libvips/blob/41cff4e9d0838498487a00623462204eb10ee5b8/libvips/iofuncs/enumtypes.c#L774)
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function pipelineColourspace (colourspace) {
+  if (!is.string(colourspace)) {
+    throw is.invalidParameterError('colourspace', 'string', colourspace);
+  }
+  this.options.colourspaceInput = colourspace;
+  return this;
+}
+
+/**
+ * Alternative spelling of `pipelineColourspace`.
+ * @param {string} [colorspace] - pipeline colorspace.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function pipelineColorspace (colorspace) {
+  return this.pipelineColourspace(colorspace);
+}
+
 /**
  * Set the output colourspace.
  * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
@@ -64,7 +103,7 @@ function grayscale (grayscale) {
  *  .toColourspace('rgb16')
  *  .toFile('16-bpp.png')
  *
- * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+ * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/3c0bfdf74ce1dc37a6429bed47fa76f16e2cd70a/libvips/iofuncs/enumtypes.c#L777-L794)
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -119,6 +158,8 @@ module.exports = function (Sharp) {
     tint,
     greyscale,
     grayscale,
+    pipelineColourspace,
+    pipelineColorspace,
     toColourspace,
     toColorspace,
     // Private

lib/composite.js

@@ -89,6 +89,8 @@ const blend = {
  * @param {Number} [images[].raw.width]
  * @param {Number} [images[].raw.height]
  * @param {Number} [images[].raw.channels]
+ * @param {boolean} [images[].failOnError=true] - @see {@link /api-constructor#parameters|constructor parameters}
+ * @param {number|boolean} [images[].limitInputPixels=268402689] - @see {@link /api-constructor#parameters|constructor parameters}
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */

lib/constructor.js

@@ -5,32 +5,7 @@ const stream = require('stream');
 const is = require('./is');
 
 require('./libvips').hasVendoredLibvips();
-
-/* istanbul ignore next */
-try {
-  require('../build/Release/sharp.node');
-} catch (err) {
-  // Bail early if bindings aren't available
-  const help = ['', 'Something went wrong installing the "sharp" module', '', err.message, ''];
-  if (/NODE_MODULE_VERSION/.test(err.message)) {
-    help.push('- Ensure the version of Node.js used at install time matches that used at runtime');
-  } else if (/invalid ELF header/.test(err.message)) {
-    help.push(`- Ensure "${process.platform}" is used at install time as well as runtime`);
-  } else if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
-    help.push('- Run "brew update && brew upgrade vips"');
-  } else {
-    help.push(
-      '- Remove the "node_modules/sharp" directory then run',
-      '  "npm install --ignore-scripts=false --verbose sharp" and look for errors'
-    );
-  }
-  help.push(
-    '- Consult the installation documentation at https://sharp.pixelplumbing.com/install',
-    '- Search for this error at https://github.com/lovell/sharp/issues', ''
-  );
-  const error = help.join('\n');
-  throw new Error(error);
-}
+require('./sharp');
 
 // Use NODE_DEBUG=sharp to enable libvips warnings
 const debuglog = util.debuglog('sharp');
@@ -38,7 +13,7 @@ const debuglog = util.debuglog('sharp');
 /**
  * Constructor factory to create an instance of `sharp`, to which further methods are chained.
  *
- * JPEG, PNG, WebP, AVIF or TIFF format image data can be streamed out from this object.
+ * JPEG, PNG, WebP, GIF, AVIF or TIFF format image data can be streamed out from this object.
  * When using Stream based output, derived attributes are available from the `info` event.
  *
  * Non-critical problems encountered during processing are emitted as `warning` events.
@@ -117,8 +92,9 @@ const debuglog = util.debuglog('sharp');
  *  }
  * }).toFile('noise.png');
  *
- * @param {(Buffer|Uint8Array|Uint8ClampedArray|string)} [input] - if present, can be
- *  a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data, or
+ * @param {(Buffer|Uint8Array|Uint8ClampedArray|Int8Array|Uint16Array|Int16Array|Uint32Array|Int32Array|Float32Array|Float64Array|string)} [input] - if present, can be
+ *  a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image data, or
+ *  a TypedArray containing raw pixel image data, or
  *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
  *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
  * @param {Object} [options] - if present, is an Object with optional attributes.
@@ -127,17 +103,21 @@ const debuglog = util.debuglog('sharp');
  * @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.unlimited=false] - Set this to `true` to remove safety features that help prevent memory exhaustion (SVG, PNG).
  * @param {boolean} [options.sequentialRead=false] - Set this to `true` to use sequential rather than random access where possible.
  *  This can reduce memory usage and might improve performance on some systems.
  * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
  * @param {number} [options.pages=1] - number of pages to extract for multi-page input (GIF, WebP, AVIF, TIFF, PDF), use -1 for all pages.
  * @param {number} [options.page=0] - page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based.
+ * @param {number} [options.subifd=-1] - subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image.
  * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
  * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`).
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
  * @param {number} [options.raw.width] - integral number of pixels wide.
  * @param {number} [options.raw.height] - integral number of pixels high.
  * @param {number} [options.raw.channels] - integral number of channels, between 1 and 4.
+ * @param {boolean} [options.raw.premultiplied] - specifies that the raw input has already been premultiplied, set to `true`
+ *  to avoid sharp premultiplying the image. (optional, default `false`)
  * @param {Object} [options.create] - describes a new image to be created.
  * @param {number} [options.create.width] - integral number of pixels wide.
  * @param {number} [options.create.height] - integral number of pixels high.
@@ -186,6 +166,7 @@ const Sharp = function (input, options) {
     extendRight: 0,
     extendBackground: [0, 0, 0, 255],
     withoutEnlargement: false,
+    withoutReduction: false,
     affineMatrix: [],
     affineBackground: [0, 0, 0, 255],
     affineIdx: 0,
@@ -201,6 +182,7 @@ const Sharp = function (input, options) {
     flatten: false,
     flattenBackground: [0, 0, 0],
     negate: false,
+    negateAlpha: true,
     medianSize: 0,
     blurSigma: 0,
     sharpenSigma: 0,
@@ -213,16 +195,21 @@ const Sharp = function (input, options) {
     gammaOut: 0,
     greyscale: false,
     normalise: false,
+    claheWidth: 0,
+    claheHeight: 0,
+    claheMaxSlope: 3,
     brightness: 1,
     saturation: 1,
     hue: 0,
+    lightness: 0,
     booleanBufferIn: null,
     booleanFileIn: '',
     joinChannelIn: [],
     extractChannel: -1,
     removeAlpha: false,
-    ensureAlpha: false,
+    ensureAlpha: -1,
     colourspace: 'srgb',
+    colourspaceInput: 'last',
     composite: [],
     // output
     fileOut: '',
@@ -230,7 +217,9 @@ const Sharp = function (input, options) {
     streamOut: false,
     withMetadata: false,
     withMetadataOrientation: -1,
+    withMetadataDensity: 0,
     withMetadataIcc: '',
+    withMetadataStrs: {},
     resolveWithObject: false,
     // output format
     jpegQuality: 80,
@@ -246,14 +235,23 @@ const Sharp = function (input, options) {
     pngAdaptiveFiltering: false,
     pngPalette: false,
     pngQuality: 100,
-    pngColours: 256,
+    pngEffort: 7,
+    pngBitdepth: 8,
     pngDither: 1,
+    jp2Quality: 80,
+    jp2TileHeight: 512,
+    jp2TileWidth: 512,
+    jp2Lossless: false,
+    jp2ChromaSubsampling: '4:4:4',
     webpQuality: 80,
     webpAlphaQuality: 100,
     webpLossless: false,
     webpNearLossless: false,
     webpSmartSubsample: false,
-    webpReductionEffort: 4,
+    webpEffort: 4,
+    gifBitdepth: 8,
+    gifEffort: 7,
+    gifDither: 1,
     tiffQuality: 80,
     tiffCompression: 'jpeg',
     tiffPredictor: 'horizontal',
@@ -264,11 +262,13 @@ const Sharp = function (input, options) {
     tiffTileWidth: 256,
     tiffXres: 1.0,
     tiffYres: 1.0,
+    tiffResolutionUnit: 'inch',
     heifQuality: 50,
     heifLossless: false,
     heifCompression: 'av1',
-    heifSpeed: 5,
-    heifChromaSubsampling: '4:2:0',
+    heifEffort: 4,
+    heifChromaSubsampling: '4:4:4',
+    rawDepth: 'uchar',
     tileSize: 256,
     tileOverlap: 0,
     tileContainer: 'fs',
@@ -280,6 +280,7 @@ const Sharp = function (input, options) {
     tileBackground: [255, 255, 255, 255],
     tileCentre: false,
     tileId: 'https://example.com/iiif',
+    timeoutSeconds: 0,
     linearA: 1,
     linearB: 0,
     // Function to notify of libvips warnings
@@ -295,7 +296,8 @@ const Sharp = function (input, options) {
   this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
   return this;
 };
-util.inherits(Sharp, stream.Duplex);
+Object.setPrototypeOf(Sharp.prototype, stream.Duplex.prototype);
+Object.setPrototypeOf(Sharp, stream.Duplex);
 
 /**
  * Take a "snapshot" of the Sharp instance, returning a new instance.

lib/input.js

@@ -2,16 +2,16 @@
 
 const color = require('color');
 const is = require('./is');
-const sharp = require('../build/Release/sharp.node');
+const sharp = require('./sharp');
 
 /**
  * Extract input options, if any, from an object.
  * @private
  */
 function _inputOptionsFromObject (obj) {
-  const { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages } = obj;
-  return [raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages].some(is.defined)
-    ? { raw, density, limitInputPixels, sequentialRead, failOnError, animated, page, pages }
+  const { raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd } = obj;
+  return [raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd].some(is.defined)
+    ? { raw, density, limitInputPixels, unlimited, sequentialRead, failOnError, animated, page, pages, subifd }
     : undefined;
 }
 
@@ -23,6 +23,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   const inputDescriptor = {
     failOnError: true,
     limitInputPixels: Math.pow(0x3FFF, 2),
+    unlimited: false,
     sequentialRead: false
   };
   if (is.string(input)) {
@@ -30,9 +31,14 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     inputDescriptor.file = input;
   } else if (is.buffer(input)) {
     // Buffer
+    if (input.length === 0) {
+      throw Error('Input Buffer is empty');
+    }
     inputDescriptor.buffer = input;
-  } else if (is.uint8Array(input)) {
-    // Uint8Array or Uint8ClampedArray
+  } else if (is.typedArray(input)) {
+    if (input.length === 0) {
+      throw Error('Input Bit Array is empty');
+    }
     inputDescriptor.buffer = Buffer.from(input.buffer);
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
@@ -78,6 +84,14 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('limitInputPixels', 'integer >= 0', inputOptions.limitInputPixels);
       }
     }
+    // unlimited
+    if (is.defined(inputOptions.unlimited)) {
+      if (is.bool(inputOptions.unlimited)) {
+        inputDescriptor.unlimited = inputOptions.unlimited;
+      } else {
+        throw is.invalidParameterError('unlimited', 'boolean', inputOptions.unlimited);
+      }
+    }
     // sequentialRead
     if (is.defined(inputOptions.sequentialRead)) {
       if (is.bool(inputOptions.sequentialRead)) {
@@ -97,6 +111,38 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.rawWidth = inputOptions.raw.width;
         inputDescriptor.rawHeight = inputOptions.raw.height;
         inputDescriptor.rawChannels = inputOptions.raw.channels;
+        inputDescriptor.rawPremultiplied = !!inputOptions.raw.premultiplied;
+
+        switch (input.constructor) {
+          case Uint8Array:
+          case Uint8ClampedArray:
+            inputDescriptor.rawDepth = 'uchar';
+            break;
+          case Int8Array:
+            inputDescriptor.rawDepth = 'char';
+            break;
+          case Uint16Array:
+            inputDescriptor.rawDepth = 'ushort';
+            break;
+          case Int16Array:
+            inputDescriptor.rawDepth = 'short';
+            break;
+          case Uint32Array:
+            inputDescriptor.rawDepth = 'uint';
+            break;
+          case Int32Array:
+            inputDescriptor.rawDepth = 'int';
+            break;
+          case Float32Array:
+            inputDescriptor.rawDepth = 'float';
+            break;
+          case Float64Array:
+            inputDescriptor.rawDepth = 'double';
+            break;
+          default:
+            inputDescriptor.rawDepth = 'uchar';
+            break;
+        }
       } else {
         throw new Error('Expected width, height and channels for raw pixel input');
       }
@@ -131,6 +177,14 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
       }
     }
+    // Sub Image File Directory (TIFF)
+    if (is.defined(inputOptions.subifd)) {
+      if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
+        inputDescriptor.subifd = inputOptions.subifd;
+      } else {
+        throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
+      }
+    }
     // Create new image
     if (is.defined(inputOptions.create)) {
       if (
@@ -236,7 +290,11 @@ function _isStreamInput () {
 }
 
 /**
- * Fast access to (uncached) image metadata without decoding any compressed image data.
+ * Fast access to (uncached) image metadata without decoding any compressed pixel data.
+ *
+ * This is taken from the header of the input image.
+ * It does not include operations, such as resize, to be applied to the output image.
+ *
  * A `Promise` is returned when `callback` is not provided.
  *
  * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
@@ -255,6 +313,10 @@ function _isStreamInput () {
  * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
  * - `pagePrimary`: Number of the primary page in a HEIF image
  * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+ * - `subifds`: Number of Sub Image File Directories in an OME-TIFF image
+ * - `background`: Default background colour, if present, for PNG (bKGD) and GIF images, either an RGB Object or a single greyscale value
+ * - `compression`: The encoder used to compress an HEIF file, `av1` (AVIF) or `hevc` (HEIC)
+ * - `resolutionUnit`: The unit of resolution (density), either `inch` or `cm`, if present
  * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
  * - `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
  * - `orientation`: Number value of the EXIF Orientation header, if present
@@ -265,6 +327,9 @@ function _isStreamInput () {
  * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
  *
  * @example
+ * const metadata = await sharp(input).metadata();
+ *
+ * @example
  * const image = sharp(inputJpg);
  * image
  *   .metadata()
@@ -340,6 +405,9 @@ function metadata (callback) {
  * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental)
  * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental)
  *
+ * **Note**: Statistics are derived from the original input image. Any operations performed on the image must first be
+ * written to a buffer in order to run `stats` on the result (see third example).
+ *
  * @example
  * const image = sharp(inputJpg);
  * image
@@ -352,6 +420,13 @@ function metadata (callback) {
  * const { entropy, sharpness, dominant } = await sharp(input).stats();
  * const { r, g, b } = dominant;
  *
+ * @example
+ * const image = sharp(input);
+ * // store intermediate result
+ * const part = await image.extract(region).toBuffer();
+ * // create new instance to obtain statistics of extracted region
+ * const stats = await sharp(part).stats();
+ *
  * @param {Function} [callback] - called with the arguments `(err, stats)`
  * @returns {Promise<Object>}
  */

lib/is.js

@@ -49,12 +49,26 @@ const buffer = function (val) {
 };
 
 /**
- * Is this value a Uint8Array or Uint8ClampedArray object?
+ * Is this value a typed array object?. E.g. Uint8Array or Uint8ClampedArray?
  * @private
  */
-const uint8Array = function (val) {
-  // allow both since Uint8ClampedArray simply clamps the values between 0-255
-  return val instanceof Uint8Array || val instanceof Uint8ClampedArray;
+const typedArray = function (val) {
+  if (defined(val)) {
+    switch (val.constructor) {
+      case Uint8Array:
+      case Uint8ClampedArray:
+      case Int8Array:
+      case Uint16Array:
+      case Int16Array:
+      case Uint32Array:
+      case Int32Array:
+      case Float32Array:
+      case Float64Array:
+        return true;
+    }
+  }
+
+  return false;
 };
 
 /**
@@ -119,7 +133,7 @@ module.exports = {
   fn: fn,
   bool: bool,
   buffer: buffer,
-  uint8Array: uint8Array,
+  typedArray: typedArray,
   string: string,
   number: number,
   integer: integer,

lib/libvips.js

@@ -4,24 +4,29 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const spawnSync = require('child_process').spawnSync;
-const semver = require('semver');
+const semverCoerce = require('semver/functions/coerce');
+const semverGreaterThanOrEqualTo = require('semver/functions/gte');
+
 const platform = require('./platform');
+const { config } = require('../package.json');
 
 const env = process.env;
 const minimumLibvipsVersionLabelled = env.npm_package_config_libvips || /* istanbul ignore next */
-  require('../package.json').config.libvips;
-const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
+  config.libvips;
+const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version;
 
 const spawnSyncOptions = {
   encoding: 'utf8',
   shell: true
 };
 
+const vendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, platform());
+
 const mkdirSync = function (dirPath) {
   try {
-    fs.mkdirSync(dirPath);
+    fs.mkdirSync(dirPath, { recursive: true });
   } catch (err) {
-    /* istanbul ignore if */
+    /* istanbul ignore next */
     if (err.code !== 'EEXIST') {
       throw err;
     }
@@ -37,9 +42,13 @@ const cachePath = function () {
   return libvipsCachePath;
 };
 
+const integrity = function (platformAndArch) {
+  return env[`npm_package_config_integrity_${platformAndArch.replace('-', '_')}`] || config.integrity[platformAndArch];
+};
+
 const log = function (item) {
   if (item instanceof Error) {
-    console.error(`sharp: ${item.message}`);
+    console.error(`sharp: Installation error: ${item.message}`);
   } else {
     console.log(`sharp: ${item}`);
   }
@@ -65,23 +74,13 @@ const globalLibvipsVersion = function () {
 };
 
 const hasVendoredLibvips = function () {
-  const currentPlatformId = platform();
-  const vendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion);
-  let vendorPlatformId;
-  try {
-    vendorPlatformId = require(path.join(vendorPath, 'platform.json'));
-  } catch (err) {}
-  /* istanbul ignore else */
-  if (vendorPlatformId) {
-    /* istanbul ignore else */
-    if (currentPlatformId === vendorPlatformId) {
-      return true;
-    } else {
-      throw new Error(`'${vendorPlatformId}' binaries cannot be used on the '${currentPlatformId}' platform. Please remove the 'node_modules/sharp' directory and run 'npm install' on the '${currentPlatformId}' platform.`);
-    }
-  } else {
-    return false;
-  }
+  return fs.existsSync(vendorPath);
+};
+
+/* istanbul ignore next */
+const removeVendoredLibvips = function () {
+  const rm = fs.rmSync ? fs.rmSync : fs.rmdirSync;
+  rm(vendorPath, { recursive: true, maxRetries: 3, force: true });
 };
 
 const pkgConfigPath = function () {
@@ -105,16 +104,18 @@ const useGlobalLibvips = function () {
   }
   const globalVipsVersion = globalLibvipsVersion();
   return !!globalVipsVersion && /* istanbul ignore next */
-    semver.gte(globalVipsVersion, minimumLibvipsVersion);
+    semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
 };
 
 module.exports = {
   minimumLibvipsVersion,
   minimumLibvipsVersionLabelled,
   cachePath,
+  integrity,
   log,
   globalLibvipsVersion,
   hasVendoredLibvips,
+  removeVendoredLibvips,
   pkgConfigPath,
   useGlobalLibvips,
   mkdirSync

lib/operation.js

@@ -245,8 +245,21 @@ function median (size) {
 
 /**
  * Blur the image.
- * When used without parameters, performs a fast, mild blur of the output image.
+ *
+ * When used without parameters, performs a fast 3x3 box blur (equivalent to a box linear filter).
+ *
  * When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
+ *
+ * @example
+ * const boxBlurred = await sharp(input)
+ *   .blur()
+ *   .toBuffer();
+ *
+ * @example
+ * const gaussianBlurred = await sharp(input)
+ *   .blur(5)
+ *   .toBuffer();
+ *
  * @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
@@ -270,9 +283,11 @@ function blur (sigma) {
 /**
  * Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
  *
+ * See also {@link /api-channel#removealpha|removeAlpha}.
+ *
  * @example
  * await sharp(rgbaInput)
- *   .flatten('#F0A703')
+ *   .flatten({ background: '#F0A703' })
  *   .toBuffer();
  *
  * @param {Object} [options]
@@ -323,11 +338,19 @@ function gamma (gamma, gammaOut) {
 
 /**
  * Produce the "negative" of the image.
- * @param {Boolean} [negate=true]
+ * @param {Object} [options]
+ * @param {Boolean} [options.alpha=true] Whether or not to negate any alpha channel
  * @returns {Sharp}
  */
-function negate (negate) {
-  this.options.negate = is.bool(negate) ? negate : true;
+function negate (options) {
+  this.options.negate = is.bool(options) ? options : true;
+  if (is.plainObject(options) && 'alpha' in options) {
+    if (!is.bool(options.alpha)) {
+      throw is.invalidParameterError('alpha', 'should be boolean value', options.alpha);
+    } else {
+      this.options.negateAlpha = options.alpha;
+    }
+  }
   return this;
 }
 
@@ -350,6 +373,47 @@ function normalize (normalize) {
   return this.normalise(normalize);
 }
 
+/**
+ * Perform contrast limiting adaptive histogram equalization
+ * {@link https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_AHE|CLAHE}.
+ *
+ * This will, in general, enhance the clarity of the image by bringing out darker details.
+ *
+ * @since 0.28.3
+ *
+ * @param {Object} options
+ * @param {number} options.width - integer width of the region in pixels.
+ * @param {number} options.height - integer height of the region in pixels.
+ * @param {number} [options.maxSlope=3] - maximum value for the slope of the
+ *  cumulative histogram. A value of 0 disables contrast limiting. Valid values
+ *  are integers in the range 0-100 (inclusive)
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function clahe (options) {
+  if (!is.plainObject(options)) {
+    throw is.invalidParameterError('options', 'plain object', options);
+  }
+  if (!('width' in options) || !is.integer(options.width) || options.width <= 0) {
+    throw is.invalidParameterError('width', 'integer above zero', options.width);
+  } else {
+    this.options.claheWidth = options.width;
+  }
+  if (!('height' in options) || !is.integer(options.height) || options.height <= 0) {
+    throw is.invalidParameterError('height', 'integer above zero', options.height);
+  } else {
+    this.options.claheHeight = options.height;
+  }
+  if (!is.defined(options.maxSlope)) {
+    this.options.claheMaxSlope = 3;
+  } else if (!is.integer(options.maxSlope) || options.maxSlope < 0 || options.maxSlope > 100) {
+    throw is.invalidParameterError('maxSlope', 'integer 0-100', options.maxSlope);
+  } else {
+    this.options.claheMaxSlope = options.maxSlope;
+  }
+  return this;
+}
+
 /**
  * Convolve the image with the specified kernel.
  *
@@ -368,7 +432,7 @@ 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 {number} kernel.height - height 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.
@@ -519,14 +583,16 @@ function recomb (inputMatrix) {
 }
 
 /**
- * Transforms the image using brightness, saturation and hue rotation.
+ * Transforms the image using brightness, saturation, hue rotation, and lightness.
+ * Brightness and lightness both operate on luminance, with the difference being that
+ * brightness is multiplicative whereas lightness is additive.
  *
  * @since 0.22.1
  *
  * @example
  * sharp(input)
  *   .modulate({
- *     brightness: 2 // increase lightness by a factor of 2
+ *     brightness: 2 // increase brightness by a factor of 2
  *   });
  *
  * sharp(input)
@@ -534,6 +600,11 @@ function recomb (inputMatrix) {
  *     hue: 180 // hue-rotate by 180 degrees
  *   });
  *
+ * sharp(input)
+ *   .modulate({
+ *     lightness: 50 // increase lightness by +50
+ *   });
+ *
  * // decreate brightness and saturation while also hue-rotating by 90 degrees
  * sharp(input)
  *   .modulate({
@@ -546,6 +617,7 @@ function recomb (inputMatrix) {
  * @param {number} [options.brightness] Brightness multiplier
  * @param {number} [options.saturation] Saturation multiplier
  * @param {number} [options.hue] Degrees for hue rotation
+ * @param {number} [options.lightness] Lightness addend
  * @returns {Sharp}
  */
 function modulate (options) {
@@ -573,6 +645,13 @@ function modulate (options) {
       throw is.invalidParameterError('hue', 'number', options.hue);
     }
   }
+  if ('lightness' in options) {
+    if (is.number(options.lightness)) {
+      this.options.lightness = options.lightness;
+    } else {
+      throw is.invalidParameterError('lightness', 'number', options.lightness);
+    }
+  }
   return this;
 }
 
@@ -594,6 +673,7 @@ module.exports = function (Sharp) {
     negate,
     normalise,
     normalize,
+    clahe,
     convolve,
     threshold,
     boolean,

lib/output.js

@@ -1,7 +1,8 @@
 'use strict';
 
+const path = require('path');
 const is = require('./is');
-const sharp = require('../build/Release/sharp.node');
+const sharp = require('./sharp');
 
 const formats = new Map([
   ['heic', 'heif'],
@@ -12,22 +13,31 @@ const formats = new Map([
   ['png', 'png'],
   ['raw', 'raw'],
   ['tiff', 'tiff'],
+  ['tif', 'tiff'],
   ['webp', 'webp'],
-  ['gif', 'gif']
+  ['gif', 'gif'],
+  ['jp2', 'jp2'],
+  ['jpx', 'jp2'],
+  ['j2k', 'jp2'],
+  ['j2c', 'jp2']
 ]);
 
-const errMagickSave = new Error('GIF output requires libvips with support for ImageMagick');
+const errJp2Save = new Error('JP2 output requires libvips with support for OpenJPEG');
+
+const bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));
 
 /**
  * Write output image data to a file.
  *
  * If an explicit output format is not selected, it will be inferred from the extension,
- * with JPEG, PNG, WebP, AVIF, TIFF, DZI, and libvips' V format supported.
+ * with JPEG, PNG, WebP, AVIF, TIFF, GIF, DZI, and libvips' V format supported.
  * Note that raw pixel data is only supported for buffer output.
  *
  * By default all metadata will be removed, which includes EXIF-based orientation.
  * See {@link withMetadata} for control over this.
  *
+ * The caller is responsible for ensuring directory structures and permissions exist.
+ *
  * A `Promise` is returned when `callback` is not provided.
  *
  * @example
@@ -52,10 +62,8 @@ function toFile (fileOut, callback) {
   let err;
   if (!is.string(fileOut)) {
     err = new Error('Missing output file path');
-  } else if (this.options.input.file === fileOut) {
+  } else if (is.string(this.options.input.file) && path.resolve(this.options.input.file) === path.resolve(fileOut)) {
     err = new Error('Cannot use same file for input and output');
-  } else if (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
-    err = errMagickSave;
   }
   if (err) {
     if (is.fn(callback)) {
@@ -72,9 +80,9 @@ function toFile (fileOut, callback) {
 
 /**
  * Write output to a Buffer.
- * JPEG, PNG, WebP, AVIF, TIFF and raw pixel data output are supported.
+ * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
  *
- * If no explicit format is set, the output format will match the input image, except GIF and SVG input which become PNG output.
+ * If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
  *
  * By default all metadata will be removed, which includes EXIF-based orientation.
  * See {@link withMetadata} for control over this.
@@ -148,9 +156,29 @@ function toBuffer (options, callback) {
  *   .toFile('output-with-metadata.jpg')
  *   .then(info => { ... });
  *
+ * @example
+ * // Set "IFD0-Copyright" in output EXIF metadata
+ * const data = await sharp(input)
+ *   .withMetadata({
+ *     exif: {
+ *       IFD0: {
+ *         Copyright: 'Wernham Hogg'
+ *       }
+ *     }
+ *   })
+ *   .toBuffer();
+ *
+ * @example
+ * // Set output metadata to 96 DPI
+ * const data = await sharp(input)
+ *   .withMetadata({ density: 96 })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {number} [options.orientation] value between 1 and 8, used to update the EXIF `Orientation` tag.
  * @param {string} [options.icc] filesystem path to output ICC profile, defaults to sRGB.
+ * @param {Object<Object>} [options.exif={}] Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data.
+ * @param {number} [options.density] Number of pixels per inch (DPI).
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -164,6 +192,13 @@ function withMetadata (options) {
         throw is.invalidParameterError('orientation', 'integer between 1 and 8', options.orientation);
       }
     }
+    if (is.defined(options.density)) {
+      if (is.number(options.density) && options.density > 0) {
+        this.options.withMetadataDensity = options.density;
+      } else {
+        throw is.invalidParameterError('density', 'positive number', options.density);
+      }
+    }
     if (is.defined(options.icc)) {
       if (is.string(options.icc)) {
         this.options.withMetadataIcc = options.icc;
@@ -171,6 +206,25 @@ function withMetadata (options) {
         throw is.invalidParameterError('icc', 'string filesystem path to ICC profile', options.icc);
       }
     }
+    if (is.defined(options.exif)) {
+      if (is.object(options.exif)) {
+        for (const [ifd, entries] of Object.entries(options.exif)) {
+          if (is.object(entries)) {
+            for (const [k, v] of Object.entries(entries)) {
+              if (is.string(v)) {
+                this.options.withMetadataStrs[`exif-${ifd.toLowerCase()}-${k}`] = v;
+              } else {
+                throw is.invalidParameterError(`exif.${ifd}.${k}`, 'string', v);
+              }
+            }
+          } else {
+            throw is.invalidParameterError(`exif.${ifd}`, 'object', entries);
+          }
+        }
+      } else {
+        throw is.invalidParameterError('exif', 'object', options.exif);
+      }
+    }
   }
   return this;
 }
@@ -319,6 +373,7 @@ function jpeg (options) {
  * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
  * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support
  * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
+ * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true`
  * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`
  * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`
  * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`
@@ -343,7 +398,7 @@ function png (options) {
     }
     if (is.defined(options.palette)) {
       this._setBooleanOption('pngPalette', options.palette);
-    } else if (is.defined(options.quality) || is.defined(options.colours || options.colors) || is.defined(options.dither)) {
+    } else if ([options.quality, options.effort, options.colours, options.colors, options.dither].some(is.defined)) {
       this._setBooleanOption('pngPalette', true);
     }
     if (this.options.pngPalette) {
@@ -354,10 +409,17 @@ function png (options) {
           throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
         }
       }
+      if (is.defined(options.effort)) {
+        if (is.integer(options.effort) && is.inRange(options.effort, 1, 10)) {
+          this.options.pngEffort = options.effort;
+        } else {
+          throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
+        }
+      }
       const colours = options.colours || options.colors;
       if (is.defined(colours)) {
         if (is.integer(colours) && is.inRange(colours, 2, 256)) {
-          this.options.pngColours = colours;
+          this.options.pngBitdepth = bitdepthFromColourCount(colours);
         } else {
           throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
         }
@@ -383,99 +445,217 @@ function png (options) {
  *   .webp({ lossless: true })
  *   .toBuffer();
  *
+ * @example
+ * // Optimise the file size of an animated WebP
+ * const outputWebp = await sharp(inputWebp, { animated: true })
+ *   .webp({ effort: 6 })
+ *   .toBuffer();
+ *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=80] - quality, integer 1-100
  * @param {number} [options.alphaQuality=100] - quality of alpha layer, integer 0-100
  * @param {boolean} [options.lossless=false] - use lossless compression mode
  * @param {boolean} [options.nearLossless=false] - use near_lossless compression mode
  * @param {boolean} [options.smartSubsample=false] - use high quality chroma subsampling
- * @param {number} [options.reductionEffort=4] - level of CPU effort to reduce file size, integer 0-6
- * @param {number} [options.pageHeight] - page height for animated output
+ * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 6 (slowest)
  * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
- * @param {number[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
 function webp (options) {
-  if (is.object(options) && is.defined(options.quality)) {
-    if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
-      this.options.webpQuality = options.quality;
-    } else {
-      throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.webpQuality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.alphaQuality)) {
+      if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
+        this.options.webpAlphaQuality = options.alphaQuality;
+      } else {
+        throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
+      }
+    }
+    if (is.defined(options.lossless)) {
+      this._setBooleanOption('webpLossless', options.lossless);
+    }
+    if (is.defined(options.nearLossless)) {
+      this._setBooleanOption('webpNearLossless', options.nearLossless);
+    }
+    if (is.defined(options.smartSubsample)) {
+      this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
+    }
+    const effort = options.effort || options.reductionEffort;
+    if (is.defined(effort)) {
+      if (is.integer(effort) && is.inRange(effort, 0, 6)) {
+        this.options.webpEffort = effort;
+      } else {
+        throw is.invalidParameterError('effort', 'integer between 0 and 6', effort);
+      }
     }
   }
-  if (is.object(options) && is.defined(options.alphaQuality)) {
-    if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
-      this.options.webpAlphaQuality = options.alphaQuality;
-    } else {
-      throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
-    }
-  }
-  if (is.object(options) && is.defined(options.lossless)) {
-    this._setBooleanOption('webpLossless', options.lossless);
-  }
-  if (is.object(options) && is.defined(options.nearLossless)) {
-    this._setBooleanOption('webpNearLossless', options.nearLossless);
-  }
-  if (is.object(options) && is.defined(options.smartSubsample)) {
-    this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
-  }
-  if (is.object(options) && is.defined(options.reductionEffort)) {
-    if (is.integer(options.reductionEffort) && is.inRange(options.reductionEffort, 0, 6)) {
-      this.options.webpReductionEffort = options.reductionEffort;
-    } else {
-      throw is.invalidParameterError('reductionEffort', 'integer between 0 and 6', options.reductionEffort);
-    }
-  }
-
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('webp', options);
 }
 
 /**
- * Use these GIF options for output image.
+ * Use these GIF options for the output image.
  *
- * Requires libvips compiled with support for ImageMagick or GraphicsMagick.
- * The prebuilt binaries do not include this - see
- * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ * The first entry in the palette is reserved for transparency.
+ *
+ * @since 0.30.0
+ *
+ * @example
+ * // Convert PNG to GIF
+ * await sharp(pngBuffer)
+ *   .gif()
+ *   .toBuffer());
+ *
+ * @example
+ * // Convert animated WebP to animated GIF
+ * await sharp('animated.webp', { animated: true })
+ *   .toFile('animated.gif');
+ *
+ * @example
+ * // Create a 128x128, cropped, non-dithered, animated thumbnail of an animated GIF
+ * const out = await sharp('in.gif', { animated: true })
+ *   .resize({ width: 128, height: 128 })
+ *   .gif({ dither: 0 })
+ *   .toBuffer();
  *
  * @param {Object} [options] - output options
- * @param {number} [options.pageHeight] - page height for animated output
+ * @param {number} [options.colours=256] - maximum number of palette entries, including transparency, between 2 and 256
+ * @param {number} [options.colors=256] - alternative spelling of `options.colours`
+ * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest)
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most)
  * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
- * @param {number[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.force=true] - force GIF output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
-/* istanbul ignore next */
 function gif (options) {
-  if (!this.constructor.format.magick.output.buffer) {
-    throw errMagickSave;
+  if (is.object(options)) {
+    const colours = options.colours || options.colors;
+    if (is.defined(colours)) {
+      if (is.integer(colours) && is.inRange(colours, 2, 256)) {
+        this.options.gifBitdepth = bitdepthFromColourCount(colours);
+      } else {
+        throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
+      }
+    }
+    if (is.defined(options.effort)) {
+      if (is.number(options.effort) && is.inRange(options.effort, 1, 10)) {
+        this.options.gifEffort = options.effort;
+      } else {
+        throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
+      }
+    }
+    if (is.defined(options.dither)) {
+      if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
+        this.options.gifDither = options.dither;
+      } else {
+        throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
+      }
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('gif', options);
 }
 
+/**
+ * Use these JP2 options for output image.
+ *
+ * Requires libvips compiled with support for OpenJPEG.
+ * The prebuilt binaries do not include this - see
+ * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ *
+ * @example
+ * // Convert any input to lossless JP2 output
+ * const data = await sharp(input)
+ *   .jp2({ lossless: true })
+ *   .toBuffer();
+ *
+ * @example
+ * // Convert any input to very high quality JP2 output
+ * const data = await sharp(input)
+ *   .jp2({
+ *     quality: 100,
+ *     chromaSubsampling: '4:4:4'
+ *   })
+ *   .toBuffer();
+ *
+ * @since 0.29.1
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=80] - quality, integer 1-100
+ * @param {boolean} [options.lossless=false] - use lossless compression mode
+ * @param {number} [options.tileWidth=512] - horizontal tile size
+ * @param {number} [options.tileHeight=512] - vertical tile size
+ * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+/* istanbul ignore next */
+function jp2 (options) {
+  if (!this.constructor.format.jp2k.output.buffer) {
+    throw errJp2Save;
+  }
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.jp2Quality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.lossless)) {
+      if (is.bool(options.lossless)) {
+        this.options.jp2Lossless = options.lossless;
+      } else {
+        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
+      }
+    }
+    if (is.defined(options.tileWidth)) {
+      if (is.integer(options.tileWidth) && is.inRange(options.tileWidth, 1, 32768)) {
+        this.options.jp2TileWidth = options.tileWidth;
+      } else {
+        throw is.invalidParameterError('tileWidth', 'integer between 1 and 32768', options.tileWidth);
+      }
+    }
+    if (is.defined(options.tileHeight)) {
+      if (is.integer(options.tileHeight) && is.inRange(options.tileHeight, 1, 32768)) {
+        this.options.jp2TileHeight = options.tileHeight;
+      } else {
+        throw is.invalidParameterError('tileHeight', 'integer between 1 and 32768', options.tileHeight);
+      }
+    }
+    if (is.defined(options.chromaSubsampling)) {
+      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
+        this.options.heifChromaSubsampling = options.chromaSubsampling;
+      } else {
+        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
+      }
+    }
+  }
+  return this._updateFormatOut('jp2', options);
+}
+
 /**
  * Set animation options if available.
  * @private
  *
  * @param {Object} [source] - output options
- * @param {number} [source.pageHeight] - page height for animated output
  * @param {number} [source.loop=0] - number of animation iterations, use 0 for infinite animation
  * @param {number[]} [source.delay] - list of delays between animation frames (in milliseconds)
  * @param {Object} [target] - target object for valid options
  * @throws {Error} Invalid options
  */
 function trySetAnimationOptions (source, target) {
-  if (is.object(source) && is.defined(source.pageHeight)) {
-    if (is.integer(source.pageHeight) && source.pageHeight > 0) {
-      target.pageHeight = source.pageHeight;
-    } else {
-      throw is.invalidParameterError('pageHeight', 'integer larger than 0', source.pageHeight);
-    }
-  }
   if (is.object(source) && is.defined(source.loop)) {
     if (is.integer(source.loop) && is.inRange(source.loop, 0, 65535)) {
       target.loop = source.loop;
@@ -484,13 +664,16 @@ function trySetAnimationOptions (source, target) {
     }
   }
   if (is.object(source) && is.defined(source.delay)) {
-    if (
+    // We allow singular values as well
+    if (is.integer(source.delay) && is.inRange(source.delay, 0, 65535)) {
+      target.delay = [source.delay];
+    } else if (
       Array.isArray(source.delay) &&
       source.delay.every(is.integer) &&
       source.delay.every(v => is.inRange(v, 0, 65535))) {
       target.delay = source.delay;
     } else {
-      throw is.invalidParameterError('delay', 'array of integers between 0 and 65535', source.delay);
+      throw is.invalidParameterError('delay', 'integer or an array of integers between 0 and 65535', source.delay);
     }
   }
 }
@@ -498,6 +681,8 @@ function trySetAnimationOptions (source, target) {
 /**
  * Use these TIFF options for output image.
  *
+ * The `density` can be set in pixels/inch via {@link withMetadata} instead of providing `xres` and `yres` in pixels/mm.
+ *
  * @example
  * // Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
  * sharp('input.svg')
@@ -519,6 +704,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.tileHeight=256] - vertical tile size
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
+ * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
  * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -592,6 +778,14 @@ function tiff (options) {
         throw is.invalidParameterError('predictor', 'one of: none, horizontal, float', options.predictor);
       }
     }
+    // resolutionUnit
+    if (is.defined(options.resolutionUnit)) {
+      if (is.string(options.resolutionUnit) && is.inArray(options.resolutionUnit, ['inch', 'cm'])) {
+        this.options.tiffResolutionUnit = options.resolutionUnit;
+      } else {
+        throw is.invalidParameterError('resolutionUnit', 'one of: inch, cm', options.resolutionUnit);
+      }
+    }
   }
   return this._updateFormatOut('tiff', options);
 }
@@ -602,13 +796,15 @@ function tiff (options) {
  * Whilst it is possible to create AVIF images smaller than 16x16 pixels,
  * most web browsers do not display these properly.
  *
+ * AVIF image sequences are not supported.
+ *
  * @since 0.27.0
  *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=50] - quality, integer 1-100
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
- * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
+ * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
+ * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -628,8 +824,8 @@ function avif (options) {
  * @param {number} [options.quality=50] - quality, integer 1-100
  * @param {string} [options.compression='av1'] - compression format: av1, hevc
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
- * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling, requires libvips v8.11.0
+ * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
+ * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -656,11 +852,17 @@ function heif (options) {
         throw is.invalidParameterError('compression', 'one of: av1, hevc', options.compression);
       }
     }
-    if (is.defined(options.speed)) {
-      if (is.integer(options.speed) && is.inRange(options.speed, 0, 8)) {
-        this.options.heifSpeed = options.speed;
+    if (is.defined(options.effort)) {
+      if (is.integer(options.effort) && is.inRange(options.effort, 0, 9)) {
+        this.options.heifEffort = options.effort;
       } else {
-        throw is.invalidParameterError('speed', 'integer between 0 and 8', options.speed);
+        throw is.invalidParameterError('effort', 'integer between 0 and 9', options.effort);
+      }
+    } else if (is.defined(options.speed)) {
+      if (is.integer(options.speed) && is.inRange(options.speed, 0, 9)) {
+        this.options.heifEffort = 9 - options.speed;
+      } else {
+        throw is.invalidParameterError('speed', 'integer between 0 and 9', options.speed);
       }
     }
     if (is.defined(options.chromaSubsampling)) {
@@ -675,28 +877,41 @@ function heif (options) {
 }
 
 /**
- * Force output to be raw, uncompressed, 8-bit unsigned integer (unit8) pixel data.
+ * Force output to be raw, uncompressed 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
+ * // Extract raw, unsigned 8-bit RGB pixel data from JPEG input
  * const { data, info } = await sharp('input.jpg')
  *   .raw()
  *   .toBuffer({ resolveWithObject: true });
  *
  * @example
- * // Extract alpha channel as raw pixel data from PNG input
+ * // Extract alpha channel as raw, unsigned 16-bit pixel data from PNG input
  * const data = await sharp('input.png')
  *   .ensureAlpha()
  *   .extractChannel(3)
  *   .toColourspace('b-w')
- *   .raw()
+ *   .raw({ depth: 'ushort' })
  *   .toBuffer();
  *
- * @returns {Sharp}
+ * @param {Object} [options] - output options
+ * @param {string} [options.depth='uchar'] - bit depth, one of: char, uchar (default), short, ushort, int, uint, float, complex, double, dpcomplex
+ * @throws {Error} Invalid options
  */
-function raw () {
+function raw (options) {
+  if (is.object(options)) {
+    if (is.defined(options.depth)) {
+      if (is.string(options.depth) && is.inArray(options.depth,
+        ['char', 'uchar', 'short', 'ushort', 'int', 'uint', 'float', 'complex', 'double', 'dpcomplex']
+      )) {
+        this.options.rawDepth = options.depth;
+      } else {
+        throw is.invalidParameterError('depth', 'one of: char, uchar, short, ushort, int, uint, float, complex, double, dpcomplex', options.depth);
+      }
+    }
+  }
   return this._updateFormatOut('raw');
 }
 
@@ -705,8 +920,6 @@ function raw () {
  * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
  * Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
  *
- * Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
- *
  * @example
  *  sharp('input.tiff')
  *   .png()
@@ -726,10 +939,10 @@ function raw () {
  * @param {string} [options.depth] how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
  * @param {number} [options.skipBlanks=-1] threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images
  * @param {string} [options.container='fs'] tile container, with value `fs` (filesystem) or `zip` (compressed file).
- * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`.
+ * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `iiif3`, `zoomify` or `google`.
  * @param {boolean} [options.centre=false] centre image in tile.
  * @param {boolean} [options.center=false] alternative spelling of centre.
- * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`, sets the `@id` attribute of `info.json`
+ * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json`
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -764,10 +977,10 @@ function tile (options) {
     }
     // Layout
     if (is.defined(options.layout)) {
-      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'zoomify'])) {
+      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'iiif3', 'zoomify'])) {
         this.options.tileLayout = options.layout;
       } else {
-        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, zoomify', options.layout);
+        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, iiif3, zoomify', options.layout);
       }
     }
     // Angle of rotation,
@@ -821,6 +1034,31 @@ function tile (options) {
   return this._updateFormatOut('dz');
 }
 
+/**
+ * Set a timeout for processing, in seconds.
+ * Use a value of zero to continue processing indefinitely, the default behaviour.
+ *
+ * The clock starts when libvips opens an input image for processing.
+ * Time spent waiting for a libuv thread to become available is not included.
+ *
+ * @since 0.29.2
+ *
+ * @param {Object} options
+ * @param {number} options.seconds - Number of seconds after which processing will be stopped
+ * @returns {Sharp}
+ */
+function timeout (options) {
+  if (!is.plainObject(options)) {
+    throw is.invalidParameterError('options', 'object', options);
+  }
+  if (is.integer(options.seconds) && is.inRange(options.seconds, 0, 3600)) {
+    this.options.timeoutSeconds = options.seconds;
+  } else {
+    throw is.invalidParameterError('seconds', 'integer between 0 and 3600', options.seconds);
+  }
+  return this;
+}
+
 /**
  * Update the output format unless options.force is false,
  * in which case revert to input format.
@@ -897,6 +1135,7 @@ function _pipeline (callback) {
             this.push(data);
           }
           this.push(null);
+          this.emit('close');
         });
       });
       if (this.streamInFinished) {
@@ -912,6 +1151,7 @@ function _pipeline (callback) {
           this.push(data);
         }
         this.push(null);
+        this.emit('close');
       });
     }
     return this;
@@ -966,6 +1206,7 @@ module.exports = function (Sharp) {
     withMetadata,
     toFormat,
     jpeg,
+    jp2,
     png,
     webp,
     tiff,
@@ -974,6 +1215,7 @@ module.exports = function (Sharp) {
     gif,
     raw,
     tile,
+    timeout,
     // Private
     _updateFormatOut,
     _setBooleanOption,

lib/platform.js

@@ -8,7 +8,7 @@ module.exports = function () {
   const arch = env.npm_config_arch || process.arch;
   const platform = env.npm_config_platform || process.platform;
   /* istanbul ignore next */
-  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinux) ? detectLibc.family : '';
+  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinuxSync()) ? detectLibc.familySync() : '';
 
   const platformId = [`${platform}${libc}`];
 

lib/resize.js

@@ -183,6 +183,20 @@ function isRotationExpected (options) {
  *   });
  *
  * @example
+ * sharp(input)
+ *   .resize(200, 200, {
+ *     fit: sharp.fit.outside,
+ *     withoutReduction: true
+ *   })
+ *   .toFormat('jpeg')
+ *   .toBuffer()
+ *   .then(function(outputBuffer) {
+ *     // outputBuffer contains JPEG image data
+ *     // of at least 200 pixels wide and 200 pixels high while maintaining aspect ratio
+ *     // and no smaller than the input image
+ *   });
+ *
+ * @example
  * const scaleByHalf = await sharp(input)
  *   .metadata()
  *   .then(({ width }) => sharp(input)
@@ -200,6 +214,7 @@ function isRotationExpected (options) {
  * @param {String|Object} [options.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour when using a `fit` of `contain`, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @param {String} [options.kernel='lanczos3'] - the kernel to use for image reduction.
  * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option.
+ * @param {Boolean} [options.withoutReduction=false] - do not reduce if the width *or* height are already greater than the specified dimensions, equivalent to GraphicsMagick's `<` geometry option.
  * @param {Boolean} [options.fastShrinkOnLoad=true] - take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -276,6 +291,10 @@ function resize (width, height, options) {
     if (is.defined(options.withoutEnlargement)) {
       this._setBooleanOption('withoutEnlargement', options.withoutEnlargement);
     }
+    // Without reduction
+    if (is.defined(options.withoutReduction)) {
+      this._setBooleanOption('withoutReduction', options.withoutReduction);
+    }
     // Shrink on load
     if (is.defined(options.fastShrinkOnLoad)) {
       this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);

lib/sharp.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const platformAndArch = require('./platform')();
+
+/* istanbul ignore next */
+try {
+  module.exports = require(`../build/Release/sharp-${platformAndArch}.node`);
+} catch (err) {
+  // Bail early if bindings aren't available
+  const help = ['', 'Something went wrong installing the "sharp" module', '', err.message, '', 'Possible solutions:'];
+  if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
+    help.push('- Update Homebrew: "brew update && brew upgrade vips"');
+  } else {
+    const [platform, arch] = platformAndArch.split('-');
+    help.push(
+      '- Install with the --verbose flag and look for errors: "npm install --ignore-scripts=false --verbose sharp"',
+      `- Install for the current ${platformAndArch} runtime: "npm install --platform=${platform} --arch=${arch} sharp"`
+    );
+  }
+  help.push(
+    '- Consult the installation documentation: https://sharp.pixelplumbing.com/install'
+  );
+  // Check loaded
+  if (process.platform === 'win32') {
+    const loadedModule = Object.keys(require.cache).find((i) => /[\\/]build[\\/]Release[\\/]sharp(.*)\.node$/.test(i));
+    if (loadedModule) {
+      const [, loadedPackage] = loadedModule.match(/node_modules[\\/]([^\\/]+)[\\/]/);
+      help.push(`- Ensure the version of sharp aligns with the ${loadedPackage} package: "npm ls sharp"`);
+    }
+  }
+  throw new Error(help.join('\n'));
+}

lib/utility.js

@@ -1,10 +1,13 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const events = require('events');
 const detectLibc = require('detect-libc');
 
 const is = require('./is');
-const sharp = require('../build/Release/sharp.node');
+const platformAndArch = require('./platform')();
+const sharp = require('./sharp');
 
 /**
  * An Object containing nested boolean values representing the available input and output formats/methods.
@@ -45,8 +48,23 @@ let versions = {
   vips: sharp.libvipsVersion()
 };
 try {
-  versions = require(`../vendor/${versions.vips}/versions.json`);
-} catch (err) {}
+  versions = require(`../vendor/${versions.vips}/${platformAndArch}/versions.json`);
+} catch (_err) { /* ignore */ }
+
+/**
+ * An Object containing the platform and architecture
+ * of the current and installed vendored binaries.
+ * @member
+ * @example
+ * console.log(sharp.vendor);
+ */
+const vendor = {
+  current: platformAndArch,
+  installed: []
+};
+try {
+  vendor.installed = fs.readdirSync(path.join(__dirname, `../vendor/${versions.vips}`));
+} catch (_err) { /* ignore */ }
 
 /**
  * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
@@ -110,7 +128,7 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* istanbul ignore next */
-if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 }
@@ -175,5 +193,6 @@ module.exports = function (Sharp) {
   Sharp.format = format;
   Sharp.interpolators = interpolators;
   Sharp.versions = versions;
+  Sharp.vendor = vendor;
   Sharp.queue = queue;
 };

package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
-  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
-  "version": "0.28.0",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
+  "version": "0.30.0",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -74,12 +74,20 @@
     "Christian Flintrup <chr@gigahost.dk>",
     "Manan Jadhav <manan@motionden.com>",
     "Leon Radley <leon@radley.se>",
-    "alza54 <alza54@thiocod.in>"
+    "alza54 <alza54@thiocod.in>",
+    "Jacob Smith <jacob@frende.me>",
+    "Michael Nutt <michael@nutt.im>",
+    "Brad Parham <baparham@gmail.com>",
+    "Taneli Vatanen <taneli.vatanen@gmail.com>",
+    "Joris Dugué <zaruike10@gmail.com>",
+    "Chris Banks <christopher.bradley.banks@gmail.com>",
+    "Ompal Singh <ompal.hitm09@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) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",
     "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
-    "test": "semistandard && cpplint && npm run test-unit && npm run test-licensing",
+    "test": "npm run test-lint && npm run test-unit && npm run test-licensing",
+    "test-lint": "semistandard && cpplint",
     "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=1000 --timeout=60000 ./test/unit/*.js",
     "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-coverage": "./test/coverage/report.sh",
@@ -107,6 +115,7 @@
     "tiff",
     "gif",
     "svg",
+    "jp2",
     "dzi",
     "image",
     "resize",
@@ -117,45 +126,58 @@
     "vips"
   ],
   "dependencies": {
-    "color": "^3.1.3",
-    "detect-libc": "^1.0.3",
-    "node-addon-api": "^3.1.0",
-    "prebuild-install": "^6.0.1",
+    "color": "^4.2.0",
+    "detect-libc": "^2.0.0",
+    "node-addon-api": "^4.3.0",
+    "prebuild-install": "^7.0.1",
     "semver": "^7.3.5",
-    "simple-get": "^3.1.0",
+    "simple-get": "^4.0.1",
     "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^3.2.0",
+    "async": "^3.2.3",
     "cc": "^3.0.1",
     "decompress-zip": "^0.3.3",
-    "documentation": "^13.2.0",
+    "documentation": "^13.2.5",
     "exif-reader": "^1.0.3",
     "icc": "^2.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^8.3.2",
-    "mock-fs": "^4.13.0",
+    "mocha": "^9.2.0",
+    "mock-fs": "^5.1.2",
     "nyc": "^15.1.0",
-    "prebuild": "^10.0.1",
+    "prebuild": "^11.0.2",
     "rimraf": "^3.0.2",
-    "semistandard": "^16.0.0"
+    "semistandard": "^16.0.1"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.10.6",
+    "libvips": "8.12.2",
+    "integrity": {
+      "darwin-arm64v8": "sha512-p46s/bbJAjkOXzPISZt9HUpG9GWjwQkYnLLRLKzsBJHLtB3X6C6Y/zXI5Hd0DOojcFkks9a0kTN+uDQ/XJY19g==",
+      "darwin-x64": "sha512-6vOHVZnvXwe6EXRsy29jdkUzBE6ElNpXUwd+m8vV7qy32AnXu7B9YemHsZ44vWviIwPZeXF6Nhd9EFLM0wWohw==",
+      "linux-arm64v8": "sha512-XwZdS63yhqLtbFtx/0eoLF/Agf5qtTrI11FMnMRpuBJWd4jHB60RAH+uzYUgoChCmKIS+AeXYMLm4d8Ns2QX8w==",
+      "linux-armv6": "sha512-Rh0Q0kqwPG2MjXWOkPCuPEyiUKFgKJYWLgS835D4MrXgdKr8Tft/eVrc2iGIxt2re30VpDiZ1h0Rby1aCZt2zw==",
+      "linux-armv7": "sha512-heTS/MsmRvu4JljINxP+vDiS9ZZfuGhr3IStb5F7Gc0/QLRhllYAg4rcO8L1eTK9sIIzG5ARvI19+YUZe7WbzA==",
+      "linux-x64": "sha512-SSWAwBFi0hx8V/h/v82tTFGKWTFv9FiCK3Timz5OExuI+sX1Ngrd0PVQaWXOThGNdel/fcD3Bz9YjSt4feBR1g==",
+      "linuxmusl-arm64v8": "sha512-Rhks+5C7p7aO6AucLT1uvzo8ohlqcqCUPgZmN+LZjsPWob/Iix3MfiDYtv/+gTvdeEfXxbCU6/YuPBwHQ7/crA==",
+      "linuxmusl-x64": "sha512-IOyjSQqpWVntqOUpCHVWuQwACwmmjdi15H8Pc+Ma1JkhPogTfVsFQWyL7DuOTD3Yr23EuYGzovUX00duOtfy/g==",
+      "win32-arm64v8": "sha512-A+Qe8Ipewtvw9ldvF6nWed2J8kphzrUE04nFeKCtNx6pfGQ/MAlCKMjt/U8VgUKNjB01zJDUW9XE0+FhGZ/UpQ==",
+      "win32-ia32": "sha512-cMrAvwFdDeAVnLJt0IPMPRKaIFhyXYGTprsM0DND9VUHE8F7dJMR44tS5YkXsGh1QNDtjKT6YuxAVUglmiXtpA==",
+      "win32-x64": "sha512-vLFIfw6aW2zABa8jpgzWDhljnE6glktrddErVyazAIoHl6BFFe/Da+LK1DbXvIYHz7fyOoKhSfCJHCiJG1Vg6w=="
+    },
     "runtime": "napi",
-    "target": 3
+    "target": 5
   },
   "engines": {
-    "node": ">=10"
+    "node": ">=12.13.0"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"
   },
   "binary": {
     "napi_versions": [
-      3
+      5
     ]
   },
   "semistandard": {

src/common.cc

@@ -36,6 +36,9 @@ namespace sharp {
   std::string AttrAsStr(Napi::Object obj, std::string attr) {
     return obj.Get(attr).As<Napi::String>();
   }
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr) {
+    return obj.Get(attr).As<Napi::String>();
+  }
   uint32_t AttrAsUint32(Napi::Object obj, std::string attr) {
     return obj.Get(attr).As<Napi::Number>().Uint32Value();
   }
@@ -89,9 +92,13 @@ namespace sharp {
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
+      descriptor->rawDepth = static_cast<VipsBandFormat>(
+        vips_enum_from_nick(nullptr, VIPS_TYPE_BAND_FORMAT,
+        AttrAsStr(input, "rawDepth").data()));
       descriptor->rawChannels = AttrAsUint32(input, "rawChannels");
       descriptor->rawWidth = AttrAsUint32(input, "rawWidth");
       descriptor->rawHeight = AttrAsUint32(input, "rawHeight");
+      descriptor->rawPremultiplied = AttrAsBool(input, "rawPremultiplied");
     }
     // Multi-page input (GIF, TIFF, PDF)
     if (HasAttr(input, "pages")) {
@@ -104,6 +111,10 @@ namespace sharp {
     if (HasAttr(input, "level")) {
       descriptor->level = AttrAsUint32(input, "level");
     }
+    // subIFD (OME-TIFF)
+    if (HasAttr(input, "subifd")) {
+      descriptor->subifd = AttrAsInt32(input, "subifd");
+    }
     // Create new image
     if (HasAttr(input, "createChannels")) {
       descriptor->createChannels = AttrAsUint32(input, "createChannels");
@@ -121,6 +132,8 @@ namespace sharp {
     descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
     // Allow switch from random to sequential access
     descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    // Remove safety features and allow unlimited SVG/PNG input
+    descriptor->unlimited = AttrAsBool(input, "unlimited");
     return descriptor;
   }
 
@@ -146,6 +159,10 @@ namespace sharp {
   bool IsGif(std::string const &str) {
     return EndsWith(str, ".gif") || EndsWith(str, ".GIF");
   }
+  bool IsJp2(std::string const &str) {
+    return EndsWith(str, ".jp2") || EndsWith(str, ".jpx") || EndsWith(str, ".j2k") || EndsWith(str, ".j2c")
+      || EndsWith(str, ".JP2") || EndsWith(str, ".JPX") || EndsWith(str, ".J2K") || EndsWith(str, ".J2C");
+  }
   bool IsTiff(std::string const &str) {
     return EndsWith(str, ".tif") || EndsWith(str, ".tiff") || EndsWith(str, ".TIF") || EndsWith(str, ".TIFF");
   }
@@ -179,6 +196,7 @@ namespace sharp {
       case ImageType::WEBP: id = "webp"; break;
       case ImageType::TIFF: id = "tiff"; break;
       case ImageType::GIF: id = "gif"; break;
+      case ImageType::JP2: id = "jp2"; break;
       case ImageType::SVG: id = "svg"; break;
       case ImageType::HEIF: id = "heif"; break;
       case ImageType::PDF: id = "pdf"; break;
@@ -215,6 +233,8 @@ namespace sharp {
     { "VipsForeignLoadGifBuffer", ImageType::GIF },
     { "VipsForeignLoadNsgifFile", ImageType::GIF },
     { "VipsForeignLoadNsgifBuffer", ImageType::GIF },
+    { "VipsForeignLoadJp2kBuffer", ImageType::JP2 },
+    { "VipsForeignLoadJp2kFile", ImageType::JP2 },
     { "VipsForeignLoadSvgFile", ImageType::SVG },
     { "VipsForeignLoadSvgBuffer", ImageType::SVG },
     { "VipsForeignLoadHeifFile", ImageType::HEIF },
@@ -223,11 +243,14 @@ namespace sharp {
     { "VipsForeignLoadPdfBuffer", ImageType::PDF },
     { "VipsForeignLoadMagickFile", ImageType::MAGICK },
     { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
+    { "VipsForeignLoadMagick7File", ImageType::MAGICK },
+    { "VipsForeignLoadMagick7Buffer", ImageType::MAGICK },
     { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
     { "VipsForeignLoadPpmFile", ImageType::PPM },
     { "VipsForeignLoadFits", ImageType::FITS },
     { "VipsForeignLoadOpenexr", ImageType::EXR },
     { "VipsForeignLoadVips", ImageType::VIPS },
+    { "VipsForeignLoadVipsFile", ImageType::VIPS },
     { "VipsForeignLoadRaw", ImageType::RAW }
   };
 
@@ -273,6 +296,7 @@ namespace sharp {
       imageType == ImageType::WEBP ||
       imageType == ImageType::MAGICK ||
       imageType == ImageType::GIF ||
+      imageType == ImageType::JP2 ||
       imageType == ImageType::TIFF ||
       imageType == ImageType::HEIF ||
       imageType == ImageType::PDF;
@@ -288,12 +312,15 @@ namespace sharp {
       if (descriptor->rawChannels > 0) {
         // Raw, uncompressed pixel data
         image = VImage::new_from_memory(descriptor->buffer, descriptor->bufferLength,
-          descriptor->rawWidth, descriptor->rawHeight, descriptor->rawChannels, VIPS_FORMAT_UCHAR);
+          descriptor->rawWidth, descriptor->rawHeight, descriptor->rawChannels, descriptor->rawDepth);
         if (descriptor->rawChannels < 3) {
           image.get_image()->Type = VIPS_INTERPRETATION_B_W;
         } else {
           image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
         }
+        if (descriptor->rawPremultiplied) {
+          image = image.unpremultiply();
+        }
         imageType = ImageType::RAW;
       } else {
         // Compressed data
@@ -303,7 +330,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -319,6 +346,9 @@ namespace sharp {
             if (imageType == ImageType::OPENSLIDE) {
               option->set("level", descriptor->level);
             }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -375,7 +405,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -391,6 +421,9 @@ namespace sharp {
             if (imageType == ImageType::OPENSLIDE) {
               option->set("level", descriptor->level);
             }
+            if (imageType == ImageType::TIFF) {
+              option->set("subifd", descriptor->subifd);
+            }
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
@@ -457,36 +490,41 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop) {
-    bool hasDelay = delay.size() != 1 || delay.front() != -1;
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop) {
+    bool hasDelay = !delay.empty();
 
-    if (pageHeight == 0 && image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
-      pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+    // Avoid a copy if none of the animation properties are needed.
+    if (nPages == 1 && !hasDelay && loop == -1) return image;
+
+    if (delay.size() == 1) {
+      // We have just one delay, repeat that value for all frames.
+      delay.insert(delay.end(), nPages - 1, delay[0]);
     }
 
-    if (!hasDelay && image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
-      delay = image.get_array_int("delay");
-      hasDelay = true;
-    }
-
-    if (loop == -1 && image.get_typeof("loop") == G_TYPE_INT) {
-      loop = image.get_int("loop");
-    }
-
-    if (pageHeight == 0) return image;
-
-    // It is necessary to create the copy as otherwise, pageHeight will be ignored!
+    // Attaching metadata, need to copy the image.
     VImage copy = image.copy();
 
-    copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
+    // Only set page-height if we have more than one page, or this could
+    // accidentally turn into an animated image later.
+    if (nPages > 1) copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
     if (hasDelay) copy.set("delay", delay);
     if (loop != -1) copy.set("loop", loop);
 
     return copy;
   }
 
+  /*
+    Remove animation properties from image.
+  */
+  VImage RemoveAnimationProperties(VImage image) {
+    VImage copy = image.copy();
+    copy.remove(VIPS_META_PAGE_HEIGHT);
+    copy.remove("delay");
+    copy.remove("loop");
+    return copy;
+  }
+
   /*
     Does this image have a non-default density?
   */
@@ -507,12 +545,19 @@ namespace sharp {
   VImage SetDensity(VImage image, const double density) {
     const double pixelsPerMm = density / 25.4;
     VImage copy = image.copy();
-    copy.set("Xres", pixelsPerMm);
-    copy.set("Yres", pixelsPerMm);
-    copy.set(VIPS_META_RESOLUTION_UNIT, "in");
+    copy.get_image()->Xres = pixelsPerMm;
+    copy.get_image()->Yres = pixelsPerMm;
     return copy;
   }
 
+  /*
+    Multi-page images can have a page height. Fetch it, and sanity check it.
+    If page-height is not set, it defaults to the image height
+  */
+  int GetPageHeight(VImage image) {
+    return vips_image_get_page_height(image.get_image());
+  }
+
   /*
     Check the proposed format supports the current dimensions.
   */
@@ -569,6 +614,33 @@ namespace sharp {
     return warning;
   }
 
+  /*
+    Attach an event listener for progress updates, used to detect timeout
+  */
+  void SetTimeout(VImage image, int const seconds) {
+    if (seconds > 0) {
+      VipsImage *im = image.get_image();
+      if (im->progress_signal == NULL) {
+        int *timeout = VIPS_NEW(im, int);
+        *timeout = seconds;
+        g_signal_connect(im, "eval", G_CALLBACK(VipsProgressCallBack), timeout);
+        vips_image_set_progress(im, TRUE);
+      }
+    }
+  }
+
+  /*
+    Event listener for progress updates, used to detect timeout
+  */
+  void VipsProgressCallBack(VipsImage *im, VipsProgress *progress, int *timeout) {
+    // printf("VipsProgressCallBack progress=%d run=%d timeout=%d\n", progress->percent, progress->run, *timeout);
+    if (*timeout > 0 && progress->run >= *timeout) {
+      vips_image_set_kill(im, TRUE);
+      vips_error("timeout", "%d%% complete", progress->percent);
+      *timeout = 0;
+    }
+  }
+
   /*
     Calculate the (left, top) coordinates of the output image
     within the input image, applying the given gravity during an embed.
@@ -737,23 +809,27 @@ namespace sharp {
   /*
     Convert RGBA value to another colourspace
   */
-  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation) {
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba,
+    VipsInterpretation const interpretation, bool premultiply) {
     int const bands = static_cast<int>(rgba.size());
-    if (bands < 3 || interpretation == VIPS_INTERPRETATION_sRGB || interpretation == VIPS_INTERPRETATION_RGB) {
+    if (bands < 3) {
       return rgba;
-    } else {
-      VImage pixel = VImage::new_matrix(1, 1);
-      pixel.set("bands", bands);
-      pixel = pixel.new_from_image(rgba);
-      pixel = pixel.colourspace(interpretation, VImage::option()->set("source_space", VIPS_INTERPRETATION_sRGB));
-      return pixel(0, 0);
     }
+    VImage pixel = VImage::new_matrix(1, 1);
+    pixel.set("bands", bands);
+    pixel = pixel
+      .new_from_image(rgba)
+      .colourspace(interpretation, VImage::option()->set("source_space", VIPS_INTERPRETATION_sRGB));
+    if (premultiply) {
+      pixel = pixel.premultiply();
+    }
+    return pixel(0, 0);
   }
 
   /*
     Apply the alpha channel to a given colour
   */
-  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour) {
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply) {
     // Scale up 8-bit values to match 16-bit input image
     double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
     // Create alphaColour colour
@@ -777,7 +853,7 @@ namespace sharp {
       alphaColour.push_back(colour[3] * multiplier);
     }
     // Ensure alphaColour colour uses correct colourspace
-    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation());
+    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation(), premultiply);
     // Add non-transparent alpha channel, if required
     if (colour[3] < 255.0 && !HasAlpha(image)) {
       image = image.bandjoin(
@@ -799,12 +875,83 @@ namespace sharp {
   /*
     Ensures alpha channel, if missing.
   */
-  VImage EnsureAlpha(VImage image) {
+  VImage EnsureAlpha(VImage image, double const value) {
     if (!HasAlpha(image)) {
       std::vector<double> alpha;
-      alpha.push_back(sharp::MaximumImageAlpha(image.interpretation()));
+      alpha.push_back(value * sharp::MaximumImageAlpha(image.interpretation()));
       image = image.bandjoin_const(alpha);
     }
     return image;
   }
+
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool swap, bool withoutEnlargement) {
+    if (swap) {
+      // Swap input width and height when requested.
+      std::swap(width, height);
+    }
+
+    double hshrink = 1.0;
+    double vshrink = 1.0;
+
+    if (targetWidth > 0 && targetHeight > 0) {
+      // Fixed width and height
+      hshrink = static_cast<double>(width) / targetWidth;
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      switch (canvas) {
+        case Canvas::CROP:
+        case Canvas::MIN:
+          if (hshrink < vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::EMBED:
+        case Canvas::MAX:
+          if (hshrink > vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::IGNORE_ASPECT:
+          if (swap) {
+            std::swap(hshrink, vshrink);
+          }
+          break;
+      }
+    } else if (targetWidth > 0) {
+      // Fixed width
+      hshrink = static_cast<double>(width) / targetWidth;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto height
+        vshrink = hshrink;
+      }
+    } else if (targetHeight > 0) {
+      // Fixed height
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto width
+        hshrink = vshrink;
+      }
+    }
+
+    // We should not enlarge (oversample) the output image,
+    // if withoutEnlargement is specified.
+    if (withoutEnlargement) {
+      hshrink = std::max(1.0, hshrink);
+      vshrink = std::max(1.0, vshrink);
+    }
+
+    // We don't want to shrink so much that we send an axis to 0
+    hshrink = std::min(hshrink, static_cast<double>(width));
+    vshrink = std::min(vshrink, static_cast<double>(height));
+
+    return std::make_pair(hshrink, vshrink);
+  }
+
 }  // namespace sharp

src/common.h

@@ -25,9 +25,9 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 6)
-#error "libvips version 8.10.6+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 12) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 12 && VIPS_MICRO_VERSION < 2)
+#error "libvips version 8.12.2+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -50,16 +50,20 @@ namespace sharp {
     char *buffer;
     bool failOnError;
     int limitInputPixels;
+    bool unlimited;
     VipsAccess access;
     size_t bufferLength;
     bool isBuffer;
     double density;
+    VipsBandFormat rawDepth;
     int rawChannels;
     int rawWidth;
     int rawHeight;
+    bool rawPremultiplied;
     int pages;
     int page;
     int level;
+    int subifd;
     int createChannels;
     int createWidth;
     int createHeight;
@@ -72,16 +76,20 @@ namespace sharp {
       buffer(nullptr),
       failOnError(TRUE),
       limitInputPixels(0x3FFF * 0x3FFF),
+      unlimited(FALSE),
       access(VIPS_ACCESS_RANDOM),
       bufferLength(0),
       isBuffer(FALSE),
       density(72.0),
+      rawDepth(VIPS_FORMAT_UCHAR),
       rawChannels(0),
       rawWidth(0),
       rawHeight(0),
+      rawPremultiplied(false),
       pages(1),
       page(0),
       level(0),
+      subifd(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
@@ -93,6 +101,7 @@ namespace sharp {
   // Convenience methods to access the attributes of a Napi::Object
   bool HasAttr(Napi::Object obj, std::string attr);
   std::string AttrAsStr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr);
   uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
   int32_t AttrAsInt32(Napi::Object obj, std::string attr);
   int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
@@ -109,6 +118,7 @@ namespace sharp {
     JPEG,
     PNG,
     WEBP,
+    JP2,
     TIFF,
     GIF,
     SVG,
@@ -125,6 +135,14 @@ namespace sharp {
     MISSING
   };
 
+  enum class Canvas {
+      CROP,
+      EMBED,
+      MAX,
+      MIN,
+      IGNORE_ASPECT
+  };
+
   // How many tasks are in the queue?
   extern volatile int counterQueue;
 
@@ -135,6 +153,7 @@ namespace sharp {
   bool IsJpeg(std::string const &str);
   bool IsPng(std::string const &str);
   bool IsWebp(std::string const &str);
+  bool IsJp2(std::string const &str);
   bool IsGif(std::string const &str);
   bool IsTiff(std::string const &str);
   bool IsHeic(std::string const &str);
@@ -197,9 +216,13 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop);
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop);
+
+  /*
+    Remove animation properties from image.
+  */
+  VImage RemoveAnimationProperties(VImage image);
 
   /*
     Does this image have a non-default density?
@@ -216,6 +239,12 @@ namespace sharp {
   */
   VImage SetDensity(VImage image, const double density);
 
+  /*
+    Multi-page images can have a page height. Fetch it, and sanity check it.
+    If page-height is not set, it defaults to the image height
+  */
+  int GetPageHeight(VImage image);
+
   /*
     Check the proposed format supports the current dimensions.
   */
@@ -236,6 +265,16 @@ namespace sharp {
   */
   std::string VipsWarningPop();
 
+  /*
+    Attach an event listener for progress updates, used to detect timeout
+  */
+  void SetTimeout(VImage image, int const timeoutSeconds);
+
+  /*
+    Event listener for progress updates, used to detect timeout
+  */
+  void VipsProgressCallBack(VipsImage *image, VipsProgress *progress, int *timeoutSeconds);
+
   /*
     Calculate the (left, top) coordinates of the output image
     within the input image, applying the given gravity during an embed.
@@ -281,12 +320,13 @@ namespace sharp {
   /*
     Convert RGBA value to another colourspace
   */
-  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba,
+    VipsInterpretation const interpretation, bool premultiply);
 
   /*
     Apply the alpha channel to a given colour
    */
-  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour);
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply);
 
   /*
     Removes alpha channel, if any.
@@ -296,7 +336,16 @@ namespace sharp {
   /*
     Ensures alpha channel, if missing.
   */
-  VImage EnsureAlpha(VImage image);
+  VImage EnsureAlpha(VImage image, double const value);
+
+  /*
+    Calculate the shrink factor, taking into account auto-rotate, the canvas
+    mode, and so on. The hshrink/vshrink are the amount to shrink the input
+    image axes by in order for the output axes (ie. after rotation) to match
+    the required thumbnail width/height and canvas mode.
+  */
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool swap, bool withoutEnlargement);
 
 }  // namespace sharp
 

src/libvips/cplusplus/VConnection.cpp

@@ -110,19 +110,6 @@ VSource::new_from_options( const char *options )
 	return( out ); 
 }
 
-VOption *
-VOption::set( const char *name, const VSource value )
-{
-	Pair *pair = new Pair( name );
-
-	pair->input = true;
-	g_value_init( &pair->value, VIPS_TYPE_SOURCE );
-	g_value_set_object( &pair->value, value.get_source() );
-	options.push_back( pair );
-
-	return( this );
-}
-
 VTarget 
 VTarget::new_to_descriptor( int descriptor )
 {
@@ -162,17 +149,4 @@ VTarget::new_to_memory()
 	return( out ); 
 }
 
-VOption *
-VOption::set( const char *name, const VTarget value )
-{
-	Pair *pair = new Pair( name );
-
-	pair->input = true;
-	g_value_init( &pair->value, VIPS_TYPE_TARGET );
-	g_value_set_object( &pair->value, value.get_target() );
-	options.push_back( pair );
-
-	return( this );
-}
-
 VIPS_NAMESPACE_END

src/libvips/cplusplus/VImage.cpp

@@ -51,6 +51,12 @@
 
 VIPS_NAMESPACE_START
 
+/**
+ * \namespace vips
+ *
+ * General docs for the vips namespace.
+ */
+
 std::vector<double>
 to_vectorv( int n, ... )
 {
@@ -87,7 +93,7 @@ negate( std::vector<double> vector )
 {
 	std::vector<double> new_vector( vector.size() );
 
-	for( unsigned int i = 0; i < vector.size(); i++ )
+	for( std::vector<double>::size_type i = 0; i < vector.size(); i++ )
 		new_vector[i] = vector[i] * -1;
 
 	return( new_vector );
@@ -98,7 +104,7 @@ invert( std::vector<double> vector )
 {
 	std::vector<double> new_vector( vector.size() );
 
-	for( unsigned int i = 0; i < vector.size(); i++ )
+	for( std::vector<double>::size_type i = 0; i < vector.size(); i++ )
 		new_vector[i] = 1.0 / vector[i];
 
 	return( new_vector );
@@ -140,6 +146,20 @@ VOption::set( const char *name, int value )
 	return( this );
 }
 
+// input guint64
+VOption *
+VOption::set( const char *name, guint64 value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, G_TYPE_UINT64 );
+	g_value_set_uint64( &pair->value, value );
+	options.push_back( pair );
+
+	return( this );
+}
+
 // input double
 VOption *
 VOption::set( const char *name, double value )
@@ -167,39 +187,17 @@ VOption::set( const char *name, const char *value )
 	return( this );
 }
 
-// input image
+// input vips object (image, source, target, etc. etc.)
 VOption *
-VOption::set( const char *name, const VImage value )
+VOption::set( const char *name, const VObject value )
 {
 	Pair *pair = new Pair( name );
+	VipsObject *object = value.get_object();
+	GType type = G_OBJECT_TYPE( object );
 
 	pair->input = true;
-	g_value_init( &pair->value, VIPS_TYPE_IMAGE );
-	g_value_set_object( &pair->value, value.get_image() );
-	options.push_back( pair );
-
-	return( this );
-}
-
-// input double array
-VOption *
-VOption::set( const char *name, std::vector<double> value )
-{
-	Pair *pair = new Pair( name );
-
-	double *array;
-	unsigned int i;
-
-	pair->input = true;
-
-	g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE );
-	vips_value_set_array_double( &pair->value, NULL,
-		static_cast< int >( value.size() ) );
-	array = vips_value_get_array_double( &pair->value, NULL );
-
-	for( i = 0; i < value.size(); i++ ) 
-		array[i] = value[i];
-
+	g_value_init( &pair->value, type );
+	g_value_set_object( &pair->value, object );
 	options.push_back( pair );
 
 	return( this );
@@ -212,7 +210,6 @@ VOption::set( const char *name, std::vector<int> value )
 	Pair *pair = new Pair( name );
 
 	int *array;
-	unsigned int i;
 
 	pair->input = true;
 
@@ -221,7 +218,30 @@ VOption::set( const char *name, std::vector<int> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_int( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) 
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) 
+		array[i] = value[i];
+
+	options.push_back( pair );
+
+	return( this );
+}
+
+// input double array
+VOption *
+VOption::set( const char *name, std::vector<double> value )
+{
+	Pair *pair = new Pair( name );
+
+	double *array;
+
+	pair->input = true;
+
+	g_value_init( &pair->value, VIPS_TYPE_ARRAY_DOUBLE );
+	vips_value_set_array_double( &pair->value, NULL,
+		static_cast< int >( value.size() ) );
+	array = vips_value_get_array_double( &pair->value, NULL );
+
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) 
 		array[i] = value[i];
 
 	options.push_back( pair );
@@ -236,7 +256,6 @@ VOption::set( const char *name, std::vector<VImage> value )
 	Pair *pair = new Pair( name );
 
 	VipsImage **array;
-	unsigned int i;
 
 	pair->input = true;
 
@@ -245,7 +264,7 @@ VOption::set( const char *name, std::vector<VImage> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_image( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) {
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) {
 		VipsImage *vips_image = value[i].get_image();
 
 		array[i] = vips_image;
@@ -466,10 +485,9 @@ VOption::get_operation( VipsOperation *operation )
 				double *array =
 					vips_value_get_array_double( value,
 					&length );
-				int j;
 
 				((*i)->vvector)->resize( length );
-				for( j = 0; j < length; j++ )
+				for( int j = 0; j < length; j++ )
 					(*((*i)->vvector))[j] = array[j];
 			}
 			else if( type == VIPS_TYPE_BLOB ) {
@@ -619,6 +637,22 @@ VImage::new_from_source( VSource source, const char *option_string,
 	return( out );
 }
 
+VImage 
+VImage::new_from_memory_steal( void *data, size_t size,
+	int width, int height, int bands, VipsBandFormat format )
+{
+	VipsImage *image;
+
+	if( !(image = vips_image_new_from_memory( data, size, 
+		width, height, bands, format )) )
+		throw( VError() );
+
+	g_signal_connect( image, "postclose",
+		G_CALLBACK( vips_image_free_buffer ), data);
+
+	return( VImage( image ) ); 
+}
+
 VImage
 VImage::new_matrix( int width, int height )
 {
@@ -680,17 +714,38 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 	const char *operation_name;
 	VipsBlob *blob;
 
+	/* Save with the new target API if we can. Fall back to the older
+	 * mechanism in case the saver we need has not been converted yet.
+	 *
+	 * We need to hide any errors from this first phase.
+	 */
 	vips__filename_split8( suffix, filename, option_string );
-	if( !(operation_name = vips_foreign_find_save_buffer( filename )) ) {
+
+	vips_error_freeze();
+	operation_name = vips_foreign_find_save_target( filename );
+	vips_error_thaw();
+
+	if( operation_name ) {
+		VTarget target = VTarget::new_to_memory();
+
+		call_option_string( operation_name, option_string,
+			(options ? options : VImage::option())->
+				set( "in", *this )->
+				set( "target", target ) );
+
+		g_object_get( target.get_target(), "blob", &blob, NULL );
+	}
+	else if( (operation_name = vips_foreign_find_save_buffer( filename )) ) {
+		call_option_string( operation_name, option_string,
+			(options ? options : VImage::option())->
+				set( "in", *this )->
+				set( "buffer", &blob ) );
+	}
+	else {
 		delete options;
 		throw VError();
 	}
 
-	call_option_string( operation_name, option_string,
-		(options ? options : VImage::option())->
-			set( "in", *this )->
-			set( "buffer", &blob ) );
-
 	if( blob ) {
 		if( buf ) {
 			*buf = VIPS_AREA( blob )->data;
@@ -729,6 +784,7 @@ std::vector<VImage>
 VImage::bandsplit( VOption *options ) const
 {
 	std::vector<VImage> b;
+	b.reserve(bands());
 
 	for( int i = 0; i < bands(); i++ )
 		b.push_back( extract_band( i ) );

src/libvips/cplusplus/VInterpolate.cpp

@@ -60,17 +60,4 @@ VInterpolate::new_from_name( const char *name, VOption *options )
 	return( out ); 
 }
 
-VOption *
-VOption::set( const char *name, const VInterpolate value )
-{
-	Pair *pair = new Pair( name );
-
-	pair->input = true;
-	g_value_init( &pair->value, VIPS_TYPE_INTERPOLATE );
-	g_value_set_object( &pair->value, value.get_interpolate() );
-	options.push_back( pair );
-
-	return( this );
-}
-
 VIPS_NAMESPACE_END

src/libvips/cplusplus/vips-operators.cpp

@@ -1,5 +1,5 @@
 // bodies for vips operations
-// Sun  5 Jul 22:36:37 BST 2020
+// Mon Nov  1 03:31:09 PM CET 2021
 // this file is generated automatically, do not edit!
 
 VImage VImage::CMC2LCh( VOption *options ) const
@@ -1065,6 +1065,18 @@ VImage VImage::fitsload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::fitsload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "fitsload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::fitssave( const char *filename, VOption *options ) const
 {
     call( "fitssave",
@@ -1250,6 +1262,34 @@ VImage VImage::gifload_source( VSource source, VOption *options )
     return( out );
 }
 
+void VImage::gifsave( const char *filename, VOption *options ) const
+{
+    call( "gifsave",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "filename", filename ) );
+}
+
+VipsBlob *VImage::gifsave_buffer( VOption *options ) const
+{
+    VipsBlob *buffer;
+
+    call( "gifsave_buffer",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "buffer", &buffer ) );
+
+    return( buffer );
+}
+
+void VImage::gifsave_target( VTarget target, VOption *options ) const
+{
+    call( "gifsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::globalbalance( VOption *options ) const
 {
     VImage out;
@@ -1656,6 +1696,70 @@ VImage VImage::join( VImage in2, VipsDirection direction, VOption *options ) con
     return( out );
 }
 
+VImage VImage::jp2kload( const char *filename, VOption *options )
+{
+    VImage out;
+
+    call( "jp2kload",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "filename", filename ) );
+
+    return( out );
+}
+
+VImage VImage::jp2kload_buffer( VipsBlob *buffer, VOption *options )
+{
+    VImage out;
+
+    call( "jp2kload_buffer",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "buffer", buffer ) );
+
+    return( out );
+}
+
+VImage VImage::jp2kload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "jp2kload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
+void VImage::jp2ksave( const char *filename, VOption *options ) const
+{
+    call( "jp2ksave",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "filename", filename ) );
+}
+
+VipsBlob *VImage::jp2ksave_buffer( VOption *options ) const
+{
+    VipsBlob *buffer;
+
+    call( "jp2ksave_buffer",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "buffer", &buffer ) );
+
+    return( buffer );
+}
+
+void VImage::jp2ksave_target( VTarget target, VOption *options ) const
+{
+    call( "jp2ksave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::jpegload( const char *filename, VOption *options )
 {
     VImage out;
@@ -1727,6 +1831,70 @@ void VImage::jpegsave_target( VTarget target, VOption *options ) const
             set( "target", target ) );
 }
 
+VImage VImage::jxlload( const char *filename, VOption *options )
+{
+    VImage out;
+
+    call( "jxlload",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "filename", filename ) );
+
+    return( out );
+}
+
+VImage VImage::jxlload_buffer( VipsBlob *buffer, VOption *options )
+{
+    VImage out;
+
+    call( "jxlload_buffer",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "buffer", buffer ) );
+
+    return( out );
+}
+
+VImage VImage::jxlload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "jxlload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
+void VImage::jxlsave( const char *filename, VOption *options ) const
+{
+    call( "jxlsave",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "filename", filename ) );
+}
+
+VipsBlob *VImage::jxlsave_buffer( VOption *options ) const
+{
+    VipsBlob *buffer;
+
+    call( "jxlsave_buffer",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "buffer", &buffer ) );
+
+    return( buffer );
+}
+
+void VImage::jxlsave_target( VTarget target, VOption *options ) const
+{
+    call( "jxlsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::labelregions( VOption *options ) const
 {
     VImage mask;
@@ -2284,6 +2452,18 @@ VImage VImage::niftiload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::niftiload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "niftiload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::niftisave( const char *filename, VOption *options ) const
 {
     call( "niftisave",
@@ -2316,6 +2496,18 @@ VImage VImage::openslideload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::openslideload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "openslideload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 VImage VImage::pdfload( const char *filename, VOption *options )
 {
     VImage out;
@@ -3388,6 +3580,18 @@ VImage VImage::vipsload( const char *filename, VOption *options )
     return( out );
 }
 
+VImage VImage::vipsload_source( VSource source, VOption *options )
+{
+    VImage out;
+
+    call( "vipsload_source",
+        (options ? options : VImage::option())->
+            set( "out", &out )->
+            set( "source", source ) );
+
+    return( out );
+}
+
 void VImage::vipssave( const char *filename, VOption *options ) const
 {
     call( "vipssave",
@@ -3396,6 +3600,14 @@ void VImage::vipssave( const char *filename, VOption *options ) const
             set( "filename", filename ) );
 }
 
+void VImage::vipssave_target( VTarget target, VOption *options ) const
+{
+    call( "vipssave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::webpload( const char *filename, VOption *options )
 {
     VImage out;

src/metadata.cc

@@ -77,6 +77,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
         baton->compression = image.get_string("heif-compression");
       }
+      if (image.get_typeof(VIPS_META_RESOLUTION_UNIT) == VIPS_TYPE_REF_STRING) {
+        baton->resolutionUnit = image.get_string(VIPS_META_RESOLUTION_UNIT);
+      }
       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++) {
@@ -86,7 +89,13 @@ class MetadataWorker : public Napi::AsyncWorker {
           baton->levels.push_back(std::pair<int, int>(width, height));
         }
       }
+      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
+        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
+      }
       baton->hasProfile = sharp::HasProfile(image);
+      if (image.get_typeof("background") == VIPS_TYPE_ARRAY_DOUBLE) {
+        baton->background = image.get_array_double("background");
+      }
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
       baton->orientation = sharp::ExifOrientation(image);
@@ -192,6 +201,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (!baton->compression.empty()) {
         info.Set("compression", baton->compression);
       }
+      if (!baton->resolutionUnit.empty()) {
+        info.Set("resolutionUnit", baton->resolutionUnit == "in" ? "inch" : baton->resolutionUnit);
+      }
       if (!baton->levels.empty()) {
         int i = 0;
         Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
@@ -203,6 +215,20 @@ class MetadataWorker : public Napi::AsyncWorker {
         }
         info.Set("levels", levels);
       }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
+      if (!baton->background.empty()) {
+        if (baton->background.size() == 3) {
+          Napi::Object background = Napi::Object::New(env);
+          background.Set("r", baton->background[0]);
+          background.Set("g", baton->background[1]);
+          background.Set("b", baton->background[2]);
+          info.Set("background", background);
+        } else {
+          info.Set("background", baton->background[0]);
+        }
+      }
       info.Set("hasProfile", baton->hasProfile);
       info.Set("hasAlpha", baton->hasAlpha);
       if (baton->orientation > 0) {

src/metadata.h

@@ -40,7 +40,10 @@ struct MetadataBaton {
   std::vector<int> delay;
   int pagePrimary;
   std::string compression;
+  std::string resolutionUnit;
   std::vector<std::pair<int, int>> levels;
+  int subifds;
+  std::vector<double> background;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -68,6 +71,7 @@ struct MetadataBaton {
     pageHeight(0),
     loop(-1),
     pagePrimary(-1),
+    subifds(0),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),

src/operations.cc

@@ -92,6 +92,13 @@ namespace sharp {
     return image;
   }
 
+  /*
+   * Contrast limiting adapative histogram equalization (CLAHE)
+   */
+  VImage Clahe(VImage image, int const width, int const height, int const maxSlope) {
+    return image.hist_local(width, height, VImage::option()->set("max_slope", maxSlope));
+  }
+
   /*
    * Gamma encoding/decoding
    */
@@ -105,6 +112,19 @@ namespace sharp {
     }
   }
 
+  /**
+   * Produce the "negative" of the image.
+   */
+  VImage Negate(VImage image, bool const negateAlpha) {
+    if (HasAlpha(image) && !negateAlpha) {
+      // Separate alpha channel
+      VImage alpha = image[image.bands() - 1];
+      return RemoveAlpha(image).invert().bandjoin(alpha);
+    } else {
+      return image.invert();
+    }
+  }
+
   /*
    * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
@@ -162,7 +182,8 @@ namespace sharp {
           0.0, 0.0, 0.0, 1.0));
   }
 
-  VImage Modulate(VImage image, double const brightness, double const saturation, int const hue) {
+  VImage Modulate(VImage image, double const brightness, double const saturation,
+                  int const hue, double const lightness) {
     if (HasAlpha(image)) {
       // Separate alpha channel
       VImage alpha = image[image.bands() - 1];
@@ -170,7 +191,7 @@ namespace sharp {
         .colourspace(VIPS_INTERPRETATION_LCH)
         .linear(
           { brightness, saturation, 1},
-          { 0.0, 0.0, static_cast<double>(hue) }
+          { lightness, 0.0, static_cast<double>(hue) }
         )
         .colourspace(VIPS_INTERPRETATION_sRGB)
         .bandjoin(alpha);
@@ -179,7 +200,7 @@ namespace sharp {
         .colourspace(VIPS_INTERPRETATION_LCH)
         .linear(
           { brightness, saturation, 1 },
-          { 0.0, 0.0, static_cast<double>(hue) }
+          { lightness, 0.0, static_cast<double>(hue) }
         )
         .colourspace(VIPS_INTERPRETATION_sRGB);
     }
@@ -275,4 +296,110 @@ namespace sharp {
       return image.linear(a, b);
     }
   }
+
+  /*
+   * Ensure the image is in a given colourspace
+   */
+  VImage EnsureColourspace(VImage image, VipsInterpretation colourspace) {
+    if (colourspace != VIPS_INTERPRETATION_LAST && image.interpretation() != colourspace) {
+      image = image.colourspace(colourspace,
+        VImage::option()->set("source_space", image.interpretation()));
+    }
+    return image;
+  }
+
+  /*
+   * Split and crop each frame, reassemble, and update pageHeight.
+   */
+  VImage CropMultiPage(VImage image, int left, int top, int width, int height,
+                       int nPages, int *pageHeight) {
+    if (top == 0 && height == *pageHeight) {
+      // Fast path; no need to adjust the height of the multi-page image
+      return image.extract_area(left, 0, width, image.height());
+    } else {
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Split the image into cropped frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(left, *pageHeight * i + top, width, height));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    }
+  }
+
+  /*
+   * Split into frames, embed each frame, reassemble, and update pageHeight.
+   */
+  VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
+                        std::vector<double> background, int nPages, int *pageHeight) {
+    if (top == 0 && height == *pageHeight) {
+      // Fast path; no need to adjust the height of the multi-page image
+      return image.embed(left, 0, width, image.height(), VImage::option()
+        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("background", background));
+    } else if (left == 0 && width == image.width()) {
+      // Fast path; no need to adjust the width of the multi-page image
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Rearrange the tall image into a vertical grid
+      image = image.grid(*pageHeight, nPages, 1);
+
+      // Do the embed on the wide image
+      image = image.embed(0, top, image.width(), height, VImage::option()
+        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("background", background));
+
+      // Split the wide image into frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(width * i, 0, width, height));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    } else {
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Split the image into frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(0, *pageHeight * i, image.width(), *pageHeight));
+      }
+
+      // Embed each frame in the target size
+      for (int i = 0; i < nPages; i++) {
+        pages[i] = pages[i].embed(left, top, width, height, VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    }
+  }
+
 }  // namespace sharp

src/operations.h

@@ -35,11 +35,21 @@ namespace sharp {
    */
   VImage Normalise(VImage image);
 
+  /*
+   * Contrast limiting adapative histogram equalization (CLAHE)
+   */
+  VImage Clahe(VImage image, int const width, int const height, int const maxSlope);
+
   /*
    * Gamma encoding/decoding
    */
   VImage Gamma(VImage image, double const exponent);
 
+  /*
+   * Produce the "negative" of the image.
+   */
+  VImage Negate(VImage image, bool const negateAlpha);
+
   /*
    * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
@@ -88,9 +98,27 @@ namespace sharp {
   VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
 
   /*
-   * Modulate brightness, saturation and hue
+   * Modulate brightness, saturation, hue and lightness
    */
-  VImage Modulate(VImage image, double const brightness, double const saturation, int const hue);
+  VImage Modulate(VImage image, double const brightness, double const saturation,
+                  int const hue, double const lightness);
+
+  /*
+   * Ensure the image is in a given colourspace
+   */
+  VImage EnsureColourspace(VImage image, VipsInterpretation colourspace);
+
+  /*
+   * Split and crop each frame, reassemble, and update pageHeight.
+   */
+  VImage CropMultiPage(VImage image, int left, int top, int width, int height,
+                       int nPages, int *pageHeight);
+
+  /*
+   * Split into frames, embed each frame, reassemble, and update pageHeight.
+   */
+  VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
+                        std::vector<double> background, int nPages, int *pageHeight);
 
 }  // namespace sharp
 

src/pipeline.h

@@ -18,6 +18,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -26,14 +27,6 @@
 
 Napi::Value pipeline(const Napi::CallbackInfo& info);
 
-enum class Canvas {
-  CROP,
-  EMBED,
-  MAX,
-  MIN,
-  IGNORE_ASPECT
-};
-
 struct Composite {
   sharp::InputDescriptor *input;
   VipsBlendMode mode;
@@ -74,7 +67,7 @@ struct PipelineBaton {
   int width;
   int height;
   int channels;
-  Canvas canvas;
+  sharp::Canvas canvas;
   int position;
   std::vector<double> resizeBackground;
   bool hasCropOffset;
@@ -89,10 +82,12 @@ struct PipelineBaton {
   bool flatten;
   std::vector<double> flattenBackground;
   bool negate;
+  bool negateAlpha;
   double blurSigma;
   double brightness;
   double saturation;
   int hue;
+  double lightness;
   int medianSize;
   double sharpenSigma;
   double sharpenFlat;
@@ -108,6 +103,9 @@ struct PipelineBaton {
   double gammaOut;
   bool greyscale;
   bool normalise;
+  int claheWidth;
+  int claheHeight;
+  int claheMaxSlope;
   bool useExifOrientation;
   int angle;
   double rotationAngle;
@@ -121,6 +119,7 @@ struct PipelineBaton {
   int extendRight;
   std::vector<double> extendBackground;
   bool withoutEnlargement;
+  bool withoutReduction;
   std::vector<double> affineMatrix;
   std::vector<double> affineBackground;
   double affineIdx;
@@ -141,14 +140,23 @@ struct PipelineBaton {
   bool pngAdaptiveFiltering;
   bool pngPalette;
   int pngQuality;
-  int pngColours;
+  int pngEffort;
+  int pngBitdepth;
   double pngDither;
+  int jp2Quality;
+  bool jp2Lossless;
+  int jp2TileHeight;
+  int jp2TileWidth;
+  std::string jp2ChromaSubsampling;
   int webpQuality;
   int webpAlphaQuality;
   bool webpNearLossless;
   bool webpLossless;
   bool webpSmartSubsample;
-  int webpReductionEffort;
+  int webpEffort;
+  int gifBitdepth;
+  int gifEffort;
+  double gifDither;
   int tiffQuality;
   VipsForeignTiffCompression tiffCompression;
   VipsForeignTiffPredictor tiffPredictor;
@@ -159,15 +167,20 @@ struct PipelineBaton {
   int tiffTileWidth;
   double tiffXres;
   double tiffYres;
+  VipsForeignTiffResunit tiffResolutionUnit;
   int heifQuality;
   VipsForeignHeifCompression heifCompression;
-  int heifSpeed;
+  int heifEffort;
   std::string heifChromaSubsampling;
   bool heifLossless;
+  VipsBandFormat rawDepth;
   std::string err;
   bool withMetadata;
   int withMetadataOrientation;
+  double withMetadataDensity;
   std::string withMetadataIcc;
+  std::unordered_map<std::string, std::string> withMetadataStrs;
+  int timeoutSeconds;
   std::unique_ptr<double[]> convKernel;
   int convKernelWidth;
   int convKernelHeight;
@@ -178,9 +191,9 @@ struct PipelineBaton {
   VipsOperationBoolean bandBoolOp;
   int extractChannel;
   bool removeAlpha;
-  bool ensureAlpha;
+  double ensureAlpha;
+  VipsInterpretation colourspaceInput;
   VipsInterpretation colourspace;
-  int pageHeight;
   std::vector<int> delay;
   int loop;
   int tileSize;
@@ -201,7 +214,7 @@ struct PipelineBaton {
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),
-    canvas(Canvas::CROP),
+    canvas(sharp::Canvas::CROP),
     position(0),
     resizeBackground{ 0.0, 0.0, 0.0, 255.0 },
     hasCropOffset(false),
@@ -213,10 +226,12 @@ struct PipelineBaton {
     flatten(false),
     flattenBackground{ 0.0, 0.0, 0.0 },
     negate(false),
+    negateAlpha(true),
     blurSigma(0.0),
     brightness(1.0),
     saturation(1.0),
     hue(0),
+    lightness(0),
     medianSize(0),
     sharpenSigma(0.0),
     sharpenFlat(1.0),
@@ -231,6 +246,9 @@ struct PipelineBaton {
     gamma(0.0),
     greyscale(false),
     normalise(false),
+    claheWidth(0),
+    claheHeight(0),
+    claheMaxSlope(3),
     useExifOrientation(false),
     angle(0),
     rotationAngle(0.0),
@@ -243,6 +261,7 @@ struct PipelineBaton {
     extendRight(0),
     extendBackground{ 0.0, 0.0, 0.0, 255.0 },
     withoutEnlargement(false),
+    withoutReduction(false),
     affineMatrix{ 1.0, 0.0, 0.0, 1.0 },
     affineBackground{ 0.0, 0.0, 0.0, 255.0 },
     affineIdx(0),
@@ -263,14 +282,20 @@ struct PipelineBaton {
     pngAdaptiveFiltering(false),
     pngPalette(false),
     pngQuality(100),
-    pngColours(256),
+    pngEffort(7),
+    pngBitdepth(8),
     pngDither(1.0),
+    jp2Quality(80),
+    jp2Lossless(false),
+    jp2TileHeight(512),
+    jp2TileWidth(512),
+    jp2ChromaSubsampling("4:4:4"),
     webpQuality(80),
     webpAlphaQuality(100),
     webpNearLossless(false),
     webpLossless(false),
     webpSmartSubsample(false),
-    webpReductionEffort(4),
+    webpEffort(4),
     tiffQuality(80),
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
@@ -281,13 +306,17 @@ struct PipelineBaton {
     tiffTileWidth(256),
     tiffXres(1.0),
     tiffYres(1.0),
+    tiffResolutionUnit(VIPS_FOREIGN_TIFF_RESUNIT_INCH),
     heifQuality(50),
     heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
-    heifSpeed(5),
-    heifChromaSubsampling("4:2:0"),
+    heifEffort(4),
+    heifChromaSubsampling("4:4:4"),
     heifLossless(false),
+    rawDepth(VIPS_FORMAT_UCHAR),
     withMetadata(false),
     withMetadataOrientation(-1),
+    withMetadataDensity(0.0),
+    timeoutSeconds(0),
     convKernelWidth(0),
     convKernelHeight(0),
     convKernelScale(0.0),
@@ -297,10 +326,9 @@ struct PipelineBaton {
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
     extractChannel(-1),
     removeAlpha(false),
-    ensureAlpha(false),
+    ensureAlpha(-1.0),
+    colourspaceInput(VIPS_INTERPRETATION_LAST),
     colourspace(VIPS_INTERPRETATION_LAST),
-    pageHeight(0),
-    delay{-1},
     loop(-1),
     tileSize(256),
     tileOverlap(0),

src/sharp.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <napi.h>
+#include <cstdlib>
 #include <vips/vips8>
 
 #include "common.h"
@@ -21,6 +22,14 @@
 #include "utilities.h"
 #include "stats.h"
 
+#if defined(_MSC_VER) && _MSC_VER >= 1400  // MSVC 2005/8
+static void empty_invalid_parameter_handler(const wchar_t* expression,
+  const wchar_t* function, const wchar_t* file, unsigned int line,
+  uintptr_t reserved) {
+  // No-op.
+}
+#endif
+
 static void* sharp_vips_init(void*) {
   g_setenv("VIPS_MIN_STACK_SIZE", "2m", FALSE);
   vips_init("sharp");
@@ -34,6 +43,13 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
     static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);
 
+  // Tell the CRT to not exit the application when an invalid parameter is
+  // passed. The main issue is that invalid FDs will trigger this behaviour.
+  // See: https://github.com/libvips/libvips/pull/2571.
+#if defined(_MSC_VER) && _MSC_VER >= 1400  // MSVC 2005/8
+  _set_invalid_parameter_handler(empty_invalid_parameter_handler);
+#endif
+
   // Methods available to JavaScript
   exports.Set("metadata", Napi::Function::New(env, metadata));
   exports.Set("pipeline", Napi::Function::New(env, pipeline));

src/utilities.cc

@@ -115,7 +115,7 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   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"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k"
   }) {
     // Input
     Napi::Boolean hasInputFile =

test/bench/package.json

@@ -8,16 +8,18 @@
     "test": "node perf && node random && node parallel"
   },
   "devDependencies": {
-    "async": "3.2.0",
+    "@squoosh/cli": "0.7.2",
+    "@squoosh/lib": "0.4.0",
+    "async": "3.2.3",
     "benchmark": "2.1.4",
     "gm": "1.23.1",
     "imagemagick": "0.1.3",
     "jimp": "0.16.1",
-    "mapnik": "4.5.6",
-    "semver": "7.3.4"
+    "mapnik": "4.5.9",
+    "semver": "7.3.5"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": "14"
+    "node": "16"
   }
 }

test/bench/perf.js

@@ -2,6 +2,7 @@
 
 const os = require('os');
 const fs = require('fs');
+const { exec } = require('child_process');
 
 const async = require('async');
 const assert = require('assert');
@@ -13,6 +14,7 @@ const gm = require('gm');
 const imagemagick = require('imagemagick');
 const mapnik = require('mapnik');
 const jimp = require('jimp');
+const squoosh = require('@squoosh/lib');
 
 const fixtures = require('../fixtures');
 
@@ -75,6 +77,65 @@ async.series({
         });
       }
     });
+    // squoosh-cli
+    jpegSuite.add('squoosh-cli-file-file', {
+      defer: true,
+      fn: function (deferred) {
+        exec(`./node_modules/.bin/squoosh-cli \
+          --output-dir ${os.tmpdir()} \
+          --resize '{"enabled":true,"width":${width},"height":${height},"method":"lanczos3","premultiply":false,"linearRGB":false}' \
+          --mozjpeg '{"quality":80,"progressive":false,"optimize_coding":true,"quant_table":0,"trellis_multipass":false,"chroma_subsample":2,"separate_chroma_quality":false}' \
+          "${fixtures.inputJpg}"`, function (err) {
+          if (err) {
+            throw err;
+          }
+          deferred.resolve();
+        });
+      }
+    });
+    // squoosh-lib (GPLv3)
+    jpegSuite.add('squoosh-lib-buffer-buffer', {
+      defer: true,
+      fn: function (deferred) {
+        const pool = new squoosh.ImagePool();
+        const image = pool.ingestImage(inputJpgBuffer);
+        image.decoded
+          .then(function () {
+            return image.preprocess({
+              resize: {
+                enabled: true,
+                width,
+                height,
+                method: 'lanczos3',
+                premultiply: false,
+                linearRGB: false
+              }
+            });
+          })
+          .then(function () {
+            return image.encode({
+              mozjpeg: {
+                quality: 80,
+                progressive: false,
+                optimize_coding: true,
+                quant_table: 0,
+                trellis_multipass: false,
+                chroma_subsample: 2,
+                separate_chroma_quality: false
+              }
+            });
+          })
+          .then(function () {
+            return pool.close();
+          })
+          .then(function () {
+            return image.encodedWith.mozjpeg;
+          })
+          .then(function () {
+            deferred.resolve();
+          });
+      }
+    });
     // mapnik
     jpegSuite.add('mapnik-file-file', {
       defer: true,

test/fixtures/index.js

@@ -2,7 +2,7 @@
 
 const path = require('path');
 const sharp = require('../../');
-const maxColourDistance = require('../../build/Release/sharp')._maxColourDistance;
+const maxColourDistance = require('../../lib/sharp')._maxColourDistance;
 
 // Helpers
 const getPath = function (filename) {
@@ -74,6 +74,7 @@ module.exports = {
   inputJpgLossless: getPath('testimgl.jpg'), // Lossless JPEG from ftp://ftp.fu-berlin.de/unix/X11/graphics/ImageMagick/delegates/ljpeg-6b.tar.gz
 
   inputPng: getPath('50020484-00001.png'), // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
+  inputPngGradients: getPath('gradients-rgb8.png'),
   inputPngWithTransparency: getPath('blackbug.png'), // public domain
   inputPngCompleteTransparency: getPath('full-transparent.png'),
   inputPngWithGreyAlpha: getPath('grey-8bit-alpha.png'),
@@ -90,6 +91,9 @@ module.exports = {
   inputPngEmbed: getPath('embedgravitybird.png'), // Released to sharp under a CC BY 4.0
   inputPngRGBWithAlpha: getPath('2569067123_aca715a2ee_o.png'), // http://www.flickr.com/photos/grizdave/2569067123/ (same as inputJpg)
   inputPngImageInAlpha: getPath('image-in-alpha.png'), // https://github.com/lovell/sharp/issues/1597
+  inputPngSolidAlpha: getPath('with-alpha.png'), // https://github.com/lovell/sharp/issues/1599
+  inputPngP3: getPath('p3.png'), // https://github.com/lovell/sharp/issues/2862
+  inputPngPalette: getPath('swiss.png'), // https://github.com/randy408/libspng/issues/188
 
   inputWebP: getPath('4.webp'), // http://www.gstatic.com/webp/gallery/4.webp
   inputWebPWithTransparency: getPath('5_webp_a.webp'), // http://www.gstatic.com/webp/gallery3/5_webp_a.webp
@@ -102,6 +106,8 @@ module.exports = {
   inputTiffUncompressed: getPath('uncompressed_tiff.tiff'), // https://code.google.com/archive/p/imagetestsuite/wikis/TIFFTestSuite.wiki file: 0c84d07e1b22b76f24cccc70d8788e4a.tif
   inputTiff8BitDepth: getPath('8bit_depth.tiff'),
   inputTifftagPhotoshop: getPath('tifftag-photoshop.tiff'), // https://github.com/lovell/sharp/issues/1600
+
+  inputJp2: getPath('relax.jp2'), // https://www.fnordware.com/j2k/relax.jp2
   inputGif: getPath('Crash_test.gif'), // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
   inputGifGreyPlusAlpha: getPath('grey-plus-alpha.gif'), // http://i.imgur.com/gZ5jlmE.gif
   inputGifAnimated: getPath('rotating-squares.gif'), // CC0 https://loading.io/spinner/blocks/-rotating-squares-preloader-gif
@@ -120,6 +126,8 @@ module.exports = {
 
   inputV: getPath('vfile.v'),
 
+  inputJpgClahe: getPath('concert.jpg'), // public domain - https://www.flickr.com/photos/mars_/14389236779/
+
   testPattern: getPath('test-pattern.png'),
 
   // Path for tests requiring human inspection