Release v0.31.1

Ignore unit coverage of fn used at install time

.circleci/config.yml

@@ -0,0 +1,79 @@
+version: 2.1
+
+workflows:
+  build:
+    jobs:
+      - linux-arm64-glibc-node-14:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-musl-node-14:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-glibc-node-18:
+          filters:
+            tags:
+              only: /^v.*/
+      - linux-arm64-musl-node-18:
+          filters:
+            tags:
+              only: /^v.*/
+
+jobs:
+  linux-arm64-glibc-node-14:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:current
+    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 fonts-noto-core"
+          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"
+      - 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 7 --upload=$prebuild_upload\" || true"
+  linux-arm64-glibc-node-18:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:current
+    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 fonts-noto-core"
+          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_18.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-14:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:current
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --volume "${PWD}:/mnt/sharp" --workdir /mnt/sharp node:14-alpine3.12
+          sudo docker exec sharp sh -c "apk add build-base git python3 font-noto --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 7 --upload=$prebuild_upload\" || true"
+  linux-arm64-musl-node-18:
+    resource_class: arm.medium
+    machine:
+      image: ubuntu-2004:current
+    steps:
+      - checkout
+      - run: |
+          sudo docker run -dit --name sharp --workdir /mnt/sharp node:18-alpine3.14
+          sudo docker exec sharp sh -c "apk add build-base git python3 font-noto --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

@@ -0,0 +1,16 @@
+freebsd_instance:
+  image_family: freebsd-14-0-snap
+
+task:
+  name: FreeBSD
+  env:
+    IGNORE_OSVERSION: yes
+  skip_notifications: true
+  prerequisites_script:
+    - pkg update -f
+    - pkg upgrade -y
+    - pkg install -y devel/pkgconf graphics/vips www/node16 www/npm
+  install_script:
+    - npm install --build-from-source --unsafe-perm
+  test_script:
+    - npm test

.gitattributes

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

.github/CONTRIBUTING.md

@@ -12,47 +12,45 @@ New bugs are assigned a `triage` label whilst under investigation.
 
 ## Submit a new feature request
 
-If a [similar request](https://github.com/lovell/sharp/labels/enhancement) exists, it's probably fastest to add a comment to it about your requirement.
+If a [similar request](https://github.com/lovell/sharp/labels/enhancement) exists,
+it's probably fastest to add a comment to it about your requirement.
 
-Implementation is usually straightforward if _libvips_ [already supports](http://www.vips.ecs.soton.ac.uk/supported/current/doc/html/libvips/ch03.html) the feature you need.
+Implementation is usually straightforward if libvips
+[already supports](https://www.libvips.org/API/current/func-list.html)
+the feature you need.
 
 ## Submit a Pull Request to fix a bug
 
 Thank you! To prevent the problem occurring again, please add unit tests that would have failed.
 
-Please select the `master` branch as the destination for your Pull Request so your fix can be included in the next minor release.
+Please select the `main` branch as the destination for your Pull Request so your fix can be included in the next minor release.
 
-Please squash your changes into a single commit using a command like `git rebase -i upstream/master`.
+Please squash your changes into a single commit using a command like `git rebase -i upstream/main`.
 
-To test C++ changes, you can compile the module using `npm install` and then run the tests using `npm test`.
+To test C++ changes, you can compile the module using `npm install --build-from-source` and then run the tests using `npm test`.
 
 ## Submit a Pull Request with a new feature
 
-Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/master/test/unit) to cover your new feature.
+Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/main/test/unit) to cover your new feature.
 A test coverage report for the JavaScript code is generated in the `coverage/lcov-report` directory.
 
 Where possible, the functional tests use gradient-based perceptual hashes
 based on [dHash](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html)
 to compare expected vs actual images.
 
-You deserve to add your details to the [list of contributors](https://github.com/lovell/sharp/blob/master/package.json#L5).
+You deserve to add your details to the [list of contributors](https://github.com/lovell/sharp/blob/main/package.json#L5).
 
 Any change that modifies the existing public API should be added to the relevant work-in-progress branch for inclusion in the next major release.
 
-| Release | WIP branch |
-| ------: | :--------- |
-| v0.12.0 | look       |
-| v0.13.0 | mind       |
-
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 
 ### Add a new public method
 
-The API tries to be as fluent as possible. Image processing concepts follow the naming conventions from _libvips_ and, to a lesser extent, _ImageMagick_.
+The API tries to be as fluent as possible.
+Image processing concepts follow the naming conventions from libvips and, to a lesser extent, ImageMagick.
 
-Most methods have optional parameters and assume sensible defaults. Methods with mandatory parameters often have names like `doSomethingWith(X)`.
-
-Please ensure backwards compatibility where possible. Methods to modify previously default behaviour often have names like `withoutOptionY()` or `withExtraZ()`.
+Most methods have optional parameters and assume sensible defaults.
+Please ensure backwards compatibility where possible.
 
 Feel free to create a [new issue](https://github.com/lovell/sharp/issues/new) to gather feedback on a potential API change.
 
@@ -60,7 +58,18 @@ Feel free to create a [new issue](https://github.com/lovell/sharp/issues/new) to
 
 A method to be removed should be deprecated in the next major version then removed in the following major version.
 
-By way of example, the [bilinearInterpolation method](https://github.com/lovell/sharp/blob/v0.6.0/index.js#L155) present in v0.5.0 was deprecated in v0.6.0 and removed in v0.7.0.
+By way of example, the `background()` method present in v0.20.0 was deprecated in v0.21.0 and removed in v0.22.0.
+
+## Documentation
+
+The public API is documented with [JSDoc](http://usejsdoc.org/) annotated comments.
+
+These can be converted to Markdown by running:
+```sh
+npm run docs-build
+```
+
+Please include documentation updates in any Pull Request that modifies the public API.
 
 ## Run the tests
 
@@ -78,15 +87,11 @@ Requires [Valgrind](http://valgrind.org/).
 npm run test-leak
 ```
 
-### Packaging tests
-
-Tests the installation on a number of Linux-based operating systems.
-Requires docker.
-
-```sh
-npm run test-packaging
-```
-
 ## Finally
 
-Please feel free to ask any questions via a [new issue](https://github.com/lovell/sharp/issues/new) or contact me by [e-mail](https://github.com/lovell/sharp/blob/master/package.json#L4).
+Please feel free to ask any questions via a
+[new issue](https://github.com/lovell/sharp/issues/new).
+
+If you're unable to post details publicly, please
+[e-mail](https://github.com/lovell/sharp/blob/main/package.json#L5)
+for private, paid consulting.

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,28 @@
+---
+name: Feature request
+about: Suggest an idea
+labels: enhancement
+
+---
+
+## Feature request
+
+### What are you trying to achieve?
+
+<!-- Please provide context here. -->
+
+### When you searched for similar feature requests, what did you find that might be related?
+
+<!-- Please demonstrate your research here. -->
+
+### What would you expect the API to look like?
+
+<!-- Please provide your suggestions here. -->
+
+### What alternatives have you considered?
+
+<!-- Please provide your ideas here. -->
+
+### Please provide sample image(s) that help explain this feature
+
+<!-- Please provide links to one or more images here. -->

.github/ISSUE_TEMPLATE/installation.md

@@ -0,0 +1,45 @@
+---
+name: Installation
+about: Something went wrong during either 'npm install sharp' or 'require("sharp")'
+labels: installation
+
+---
+
+<!-- Please try to answer as many of these questions as possible. -->
+
+## Possible install-time or require-time problem
+
+<!-- Please place an [x] in the box to confirm. -->
+
+- [ ] I have read the [documentation relating to installation](https://sharp.pixelplumbing.com/install).
+- [ ] I have ensured that the architecture and platform of Node.js used for `npm install` is the same as the architecture and platform of Node.js used at runtime.
+
+### Are you using the latest version of sharp?
+
+<!-- Please place an [x] in the box to confirm. -->
+
+- [ ] I am using the latest version of `sharp` as reported by `npm view sharp dist-tags.latest`.
+
+If you cannot confirm this, please upgrade to the latest version and try again before opening an issue.
+
+If you are using another package which depends on a version of `sharp` that is not the latest, please open an issue against that package instead.
+
+### Is this a problem with filesystem permissions?
+
+If you are using npm v6 or earlier and installing as a `root` or `sudo` user, have you tried with the `npm install --unsafe-perm` flag?
+
+If you are using npm v7 or later, does the user running `npm install` own the directory it is run in?
+
+If you are using the `ignore-scripts` feature of `npm`, have you tried with the `npm install --ignore-scripts=false` flag?
+
+### What is the complete output of running `npm install --verbose --foreground-scripts sharp` in an empty directory?
+
+<details>
+
+<!-- Please provide output of `npm install --verbose --foreground-scripts sharp` in an empty directory here. -->
+
+</details>
+
+### What is the output of running `npx envinfo --binaries --system --npmPackages=sharp --npmGlobalPackages=sharp`?
+
+<!-- Please provide output of `npx envinfo --binaries --system --npmPackages=sharp --npmGlobalPackages=sharp` here. -->

.github/ISSUE_TEMPLATE/possible-bug.md

@@ -0,0 +1,49 @@
+---
+name: Possible bug
+about: Installation of sharp was successful but then something unexpected occurred using one of its features
+labels: triage
+
+---
+
+<!-- If this issue relates to installation, please use https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md instead. -->
+
+## Possible bug
+
+### Is this a possible bug in a feature of sharp, unrelated to installation?
+
+<!-- Please place an [x] in the box to confirm. -->
+
+- [ ] Running `npm install sharp` completes without error.
+- [ ] Running `node -e "require('sharp')"` completes without error.
+
+If you cannot confirm both of these, please open an [installation issue](https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md) instead.
+
+### Are you using the latest version of sharp?
+
+<!-- Please place an [x] in the box to confirm. -->
+
+- [ ] I am using the latest version of `sharp` as reported by `npm view sharp dist-tags.latest`.
+
+If you cannot confirm this, please upgrade to the latest version and try again before opening an issue.
+
+If you are using another package which depends on a version of `sharp` that is not the latest, please open an issue against that package instead.
+
+### What is the output of running `npx envinfo --binaries --system --npmPackages=sharp --npmGlobalPackages=sharp`?
+
+<!-- Please provide output of the above command here. -->
+
+### What are the steps to reproduce?
+
+<!-- Please enter steps to reproduce here. -->
+
+### What is the expected behaviour?
+
+<!-- Please enter the expected behaviour here. -->
+
+### Please provide a minimal, standalone code sample, without other dependencies, that demonstrates this problem
+
+<!-- Please provide either formatted code or a link to a repo/gist that allows someone else to reproduce here. -->
+
+### Please provide sample image(s) that help explain this problem
+
+<!-- Please provide links to one or more images here. -->

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,26 @@
+---
+name: Question
+about: For help understanding an existing feature
+labels: question
+
+---
+
+<!-- If this issue relates to installation, please use https://github.com/lovell/sharp/issues/new?labels=installation&template=installation.md instead. -->
+
+## Question about an existing feature
+
+### What are you trying to achieve?
+
+<!-- Please provide context here. -->
+
+### When you searched for similar issues, what did you find that might be related?
+
+<!-- Please demonstrate your research here. -->
+
+### Please provide a minimal, standalone code sample, without other dependencies, that demonstrates this question
+
+<!-- Please provide either formatted code or a link to a repo/gist that helps someone else understand here. -->
+
+### Please provide sample image(s) that help explain this question
+
+<!-- Please provide links to one or more images here. -->

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

@@ -0,0 +1,40 @@
+name: CI (MacStadium)
+on:
+  - push
+  - pull_request
+permissions: {}
+jobs:
+  CI:
+    permissions:
+      contents: write # for npx prebuild to make release
+    name: Node.js ${{ matrix.nodejs_version }} ${{ matrix.nodejs_arch }} ${{ matrix.prebuild && '- prebuild' }}
+    runs-on: macos-m1
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - nodejs_version: 14
+            nodejs_arch: x64
+          - nodejs_version: 18
+            nodejs_arch: arm64
+            prebuild: true
+    defaults:
+      run:
+        shell: /usr/bin/arch -arch arm64e /bin/bash -l {0}
+    steps:
+      - name: Dependencies
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.nodejs_version }}
+          architecture: ${{ matrix.nodejs_arch }}
+      - 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 7

.github/workflows/ci.yml

@@ -0,0 +1,100 @@
+name: CI (GitHub)
+on:
+  - push
+  - pull_request
+permissions: {}
+jobs:
+  CI:
+    permissions:
+      contents: write # for npx prebuild to make release
+    name: ${{ matrix.container || matrix.os }} - Node.js ${{ matrix.nodejs_version }} ${{ matrix.nodejs_arch }} ${{ matrix.prebuild && '- prebuild' }}
+    runs-on: ${{ matrix.os }}
+    container: ${{ matrix.container }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            container: centos:7
+            nodejs_version: 14
+            prebuild: true
+          - os: ubuntu-22.04
+            container: centos:7
+            nodejs_version: 16
+          - os: ubuntu-22.04
+            container: rockylinux:8
+            nodejs_version: 18
+          - os: ubuntu-22.04
+            container: node:14-alpine3.12
+            prebuild: true
+          - os: ubuntu-22.04
+            container: node:16-alpine3.12
+          - os: ubuntu-22.04
+            container: node:18-alpine3.14
+          - os: macos-11
+            nodejs_version: 14
+            prebuild: true
+            nodejs_arch: x64
+          - os: macos-11
+            nodejs_version: 16
+            nodejs_arch: x64
+          - os: macos-11
+            nodejs_version: 18
+            nodejs_arch: x64
+          - os: windows-2019
+            nodejs_version: 14
+            nodejs_arch: x86
+            prebuild: true
+          - os: windows-2019
+            nodejs_version: 16
+            nodejs_arch: x86
+          - os: windows-2019
+            nodejs_version: 18
+            nodejs_arch: x86
+          - os: windows-2019
+            nodejs_version: 14
+            nodejs_arch: x64
+            prebuild: true
+          - os: windows-2019
+            nodejs_version: 16
+            nodejs_arch: x64
+          - os: windows-2019
+            nodejs_version: 18
+            nodejs_arch: x64
+    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 centos-release-scl
+          yum install -y devtoolset-11-gcc-c++ make git python3 nodejs fontconfig google-noto-sans-fonts
+          echo "/opt/rh/devtoolset-11/root/usr/bin" >> $GITHUB_PATH
+      - name: Dependencies (Rocky Linux glibc)
+        if: contains(matrix.container, 'rockylinux')
+        run: |
+          curl -sL https://rpm.nodesource.com/setup_${{ matrix.nodejs_version }}.x | bash -
+          dnf install -y gcc-toolset-11-gcc-c++ make git python3 nodejs fontconfig google-noto-sans-fonts
+          echo "/opt/rh/gcc-toolset-11/root/usr/bin" >> $GITHUB_PATH
+      - name: Dependencies (Linux musl)
+        if: contains(matrix.container, 'alpine')
+        run: apk add build-base git python3 font-noto --update-cache
+      - name: Dependencies (macOS, Windows)
+        if: contains(matrix.os, 'macos') || contains(matrix.os, 'windows')
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.nodejs_version }}
+          architecture: ${{ matrix.nodejs_arch }}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Fix working directory ownership
+        if: matrix.container
+        run: chown root.root .
+      - name: Install
+        run: npm install --build-from-source --unsafe-perm
+      - name: Test
+        run: npm test
+      - name: Prebuild
+        if: matrix.prebuild && startsWith(github.ref, 'refs/tags/')
+        env:
+          prebuild_upload: ${{ secrets.GITHUB_TOKEN }}
+        run: npx prebuild --runtime napi --target 7

.gitignore

@@ -1,11 +1,18 @@
 build
 node_modules
-coverage
+/coverage
 test/bench/node_modules
 test/fixtures/output*
 test/leak/libvips.supp
-lib
-include
-packaging/libvips*
-packaging/*.log
+test/saliency/report.json
+test/saliency/Image*
+test/saliency/[Uu]serData*
+!test/saliency/userData.js
+vendor
+.gitattributes
 .DS_Store
+.nyc_output
+.vscode/
+package-lock.json
+.idea
+.firebase

.jshintignore

@@ -1,3 +0,0 @@
-node_modules
-test/bench/node_modules
-coverage

.jshintrc

@@ -1,11 +0,0 @@
-{
-  "strict": true,
-  "node": true,
-  "maxparams": 4,
-  "maxcomplexity": 13,
-  "globals": {
-    "before": true,
-    "describe": true,
-    "it": true
-  }
-}

.npmignore

@@ -1,15 +0,0 @@
-build
-node_modules
-coverage
-.editorconfig
-.jshintignore
-.jshintrc
-.gitignore
-test
-.travis.yml
-appveyor.yml
-circle.yml
-mkdocs.yml
-lib
-include
-packaging

.prebuildrc

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

.travis.yml

@@ -1,17 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"
-  - "0.12"
-  - "4"
-  - "5"
-sudo: false
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - g++-4.8
-env:
-  CXX=g++-4.8
-after_success:
-  - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js

README.md

@@ -1,47 +1,113 @@
 # sharp
 
-The typical use case for this high speed Node.js module
-is to convert large images of many formats to
-smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
+<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
 
-Resizing an image is typically 4x faster than using the
-quickest ImageMagick and GraphicsMagick settings.
+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, GIF and AVIF images of varying dimensions.
+
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings
+due to its use of [libvips](https://github.com/libvips/libvips).
 
 Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
+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 Windows (x64), Linux and ARMv6+ systems do not require
-the installation of any external runtime dependencies.
+Most modern macOS, Windows and Linux systems running Node.js >= 14.15.0
+do not require any additional install or runtime dependencies.
 
-Use with OS X is as simple as running `brew install homebrew/science/vips`
-to install the libvips dependency.
+## Documentation
 
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
 
-### Documentation
+## Examples
 
-Visit [sharp.dimens.io](http://sharp.dimens.io/) for complete
-[installation instructions](http://sharp.dimens.io/page/install),
-[API documentation](http://sharp.dimens.io/page/api),
-[benchmark tests](http://sharp.dimens.io/page/performance) and
-[changelog](http://sharp.dimens.io/page/changelog).
+```sh
+npm install sharp
+```
 
-### Contributing
+```javascript
+const sharp = require('sharp');
+```
 
-A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
+### Callback
+
+```javascript
+sharp(inputBuffer)
+  .resize(320, 240)
+  .toFile('output.webp', (err, info) => { ... });
+```
+
+### Promise
+
+```javascript
+sharp('input.jpg')
+  .rotate()
+  .resize(200)
+  .jpeg({ mozjpeg: true })
+  .toBuffer()
+  .then( data => { ... })
+  .catch( err => { ... });
+```
+
+### Async/await
+
+```javascript
+const semiTransparentRedPng = await sharp({
+  create: {
+    width: 48,
+    height: 48,
+    channels: 4,
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+  }
+})
+  .png()
+  .toBuffer();
+```
+
+### Stream
+
+```javascript
+const roundedCorners = Buffer.from(
+  '<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>'
+);
+
+const roundedCornerResizer =
+  sharp()
+    .resize(200, 200)
+    .composite([{
+      input: roundedCorners,
+      blend: 'dest-in'
+    }])
+    .png();
+
+readableStream
+  .pipe(roundedCornerResizer)
+  .pipe(writableStream);
+```
+
+## Contributing
+
+A [guide for contributors](https://github.com/lovell/sharp/blob/main/.github/CONTRIBUTING.md)
 covers reporting bugs, requesting features and submitting code changes.
 
-### Licence
+[![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)
 
-Copyright 2013, 2014, 2015, 2016 Lovell Fuller and contributors.
+## Licensing
+
+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.
 You may obtain a copy of the License at
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

appveyor.yml

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

binding.gyp

@@ -1,109 +1,172 @@
 {
+  'variables': {
+    'vips_version': '<!(node -p "require(\'./lib/libvips\').minimumLibvipsVersion")',
+    'platform_and_arch': '<!(node -p "require(\'./lib/platform\')()")',
+    'sharp_vendor_dir': './vendor/<(vips_version)/<(platform_and_arch)'
+  },
   'targets': [{
-    'target_name': 'sharp',
-    # Nested variables "pattern" borrowed from http://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi
-    'variables': {
-      'variables': {
-        'variables': {
-          'conditions': [
-            ['OS != "win"', {
-              # Build the PKG_CONFIG_PATH environment variable with all possible combinations
-              'pkg_config_path': '<!(which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true):$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig'
-            }, {
-              'pkg_config_path': ''
-            }]
+    'target_name': 'libvips-cpp',
+    'conditions': [
+      ['OS == "win"', {
+        # Build libvips C++ binding for Windows due to MSVC std library ABI changes
+        'type': 'shared_library',
+        'defines': [
+          'VIPS_CPLUSPLUS_EXPORTS',
+          '_ALLOW_KEYWORD_MACROS'
+        ],
+        'sources': [
+          'src/libvips/cplusplus/VConnection.cpp',
+          'src/libvips/cplusplus/VError.cpp',
+          'src/libvips/cplusplus/VImage.cpp',
+          'src/libvips/cplusplus/VInterpolate.cpp',
+          'src/libvips/cplusplus/VRegion.cpp'
+        ],
+        'include_dirs': [
+          '<(sharp_vendor_dir)/include',
+          '<(sharp_vendor_dir)/include/glib-2.0',
+          '<(sharp_vendor_dir)/lib/glib-2.0/include'
+        ],
+        'link_settings': {
+          'library_dirs': ['<(sharp_vendor_dir)/lib'],
+          'libraries': [
+            'libvips.lib',
+            'libglib-2.0.lib',
+            'libgobject-2.0.lib'
           ],
         },
-        'conditions': [
-          ['OS != "win"', {
-            # Which version, if any, of libvips is available globally via pkg-config?
-            'global_vips_version': '<!(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --modversion vips 2>/dev/null || true)'
-          }, {
-            'global_vips_version': ''
-          }]
-        ],
-        'pkg_config_path%': '<(pkg_config_path)'
-      },
-      'pkg_config_path%': '<(pkg_config_path)',
+        'configurations': {
+          'Release': {
+            'msvs_settings': {
+              'VCCLCompilerTool': {
+                'ExceptionHandling': 1,
+                'Optimization': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              }
+            },
+            'msvs_disabled_warnings': [
+              4275
+            ]
+          }
+        }
+      }, {
+        # Ignore this target for non-Windows
+        'type': 'none'
+      }]
+    ]
+  }, {
+    'target_name': 'sharp-<(platform_and_arch)',
+    'defines': [
+      'NAPI_VERSION=7'
+    ],
+    'dependencies': [
+      '<!(node -p "require(\'node-addon-api\').gyp")',
+      'libvips-cpp'
+    ],
+    'variables': {
       'runtime_link%': 'shared',
       'conditions': [
         ['OS != "win"', {
-          # Does the globally available version of libvips, if any, meet the minimum version requirement?
-          'use_global_vips': '<!(GLOBAL_VIPS_VERSION="<(global_vips_version)" node -e "require(\'./binding\').use_global_vips()")'
+          'pkg_config_path': '<!(node -p "require(\'./lib/libvips\').pkgConfigPath()")',
+          'use_global_libvips': '<!(node -p "Boolean(require(\'./lib/libvips\').useGlobalLibvips()).toString()")'
         }, {
-          'use_global_vips': ''
+          'pkg_config_path': '',
+          'use_global_libvips': ''
         }]
       ]
     },
     'sources': [
       'src/common.cc',
       'src/metadata.cc',
+      'src/stats.cc',
       'src/operations.cc',
       'src/pipeline.cc',
-      'src/sharp.cc',
-      'src/utilities.cc'
+      'src/utilities.cc',
+      'src/sharp.cc'
     ],
     'include_dirs': [
-      '<!(node -e "require(\'nan\')")'
+      '<!(node -p "require(\'node-addon-api\').include_dir")',
     ],
     'conditions': [
-      ['use_global_vips == "true"', {
+      ['use_global_libvips == "true"', {
         # Use pkg-config for include and lib
-        'include_dirs': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --cflags-only-I vips glib-2.0 | sed s\/-I//g)'],
+        'include_dirs': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --cflags-only-I vips-cpp vips glib-2.0 | sed s\/-I//g)'],
         'conditions': [
           ['runtime_link == "static"', {
-            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs --static vips)']
+            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs --static vips-cpp)']
           }, {
-            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips)']
+            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips-cpp)']
+          }],
+          ['OS == "linux"', {
+            'defines': [
+              # Inspect libvips-cpp.so to determine which C++11 ABI version was used and set _GLIBCXX_USE_CXX11_ABI accordingly. This is quite horrible.
+              '_GLIBCXX_USE_CXX11_ABI=<!(if readelf -Ws "$(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --variable libdir vips-cpp)/libvips-cpp.so" | c++filt | grep -qF __cxx11;then echo "1";else echo "0";fi)'
+            ]
           }]
         ]
       }, {
-        # Attempt to download pre-built libvips and install locally within node_modules
+        # Use pre-built libvips stored locally within node_modules
         'include_dirs': [
-          '<(module_root_dir)/include',
-          '<(module_root_dir)/include/glib-2.0',
-          '<(module_root_dir)/lib/glib-2.0/include'
+          '<(sharp_vendor_dir)/include',
+          '<(sharp_vendor_dir)/include/glib-2.0',
+          '<(sharp_vendor_dir)/lib/glib-2.0/include'
         ],
         'conditions': [
           ['OS == "win"', {
-            'variables': {
-              'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
+            'defines': [
+              '_ALLOW_KEYWORD_MACROS',
+              '_FILE_OFFSET_BITS=64'
+            ],
+            'link_settings': {
+              'library_dirs': ['<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips.lib',
+                'libglib-2.0.lib',
+                'libgobject-2.0.lib'
+              ]
+            }
+          }],
+          ['OS == "mac"', {
+            'link_settings': {
+              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                'libvips-cpp.42.dylib'
+              ]
             },
-            'libraries': [
-              '<(module_root_dir)/lib/libvips.lib',
-              '<(module_root_dir)/lib/libglib-2.0.lib',
-              '<(module_root_dir)/lib/libgobject-2.0.lib'
-            ]
+            'xcode_settings': {
+              'OTHER_LDFLAGS': [
+                # Ensure runtime linking is relative to sharp.node
+                '-Wl,-rpath,\'@loader_path/../../<(sharp_vendor_dir)/lib\''
+              ]
+            }
           }],
           ['OS == "linux"', {
-            'variables': {
-              'download_vips': '<!(LDD_VERSION="<!(ldd --version 2>&1 || true)" node -e "require(\'./binding\').download_vips()")'
-            },
-            'libraries': [
-              '<(module_root_dir)/lib/libvips.so',
-              '<(module_root_dir)/lib/libglib-2.0.so',
-              '<(module_root_dir)/lib/libgobject-2.0.so',
-              # Dependencies of dependencies, included for openSUSE support
-              '<(module_root_dir)/lib/libMagickCore-6.Q16.so',
-              '<(module_root_dir)/lib/libMagickWand-6.Q16.so',
-              '<(module_root_dir)/lib/libexif.so',
-              '<(module_root_dir)/lib/libgio-2.0.so',
-              '<(module_root_dir)/lib/libgmodule-2.0.so',
-              '<(module_root_dir)/lib/libgsf-1.so',
-              '<(module_root_dir)/lib/libjpeg.so',
-              '<(module_root_dir)/lib/libpng.so',
-              '<(module_root_dir)/lib/libtiff.so',
-              '<(module_root_dir)/lib/libwebp.so',
-              '<(module_root_dir)/lib/libz.so',
-              '<(module_root_dir)/lib/libffi.so',
-              '<(module_root_dir)/lib/libgthread-2.0.so',
-              '<(module_root_dir)/lib/liblcms2.so',
-              '<(module_root_dir)/lib/libpng16.so',
-              '<(module_root_dir)/lib/libxml2.so',
-              '<(module_root_dir)/lib/liborc-0.4.so',
-              # Ensure runtime linking is relative to sharp.node
-              '-Wl,-rpath=\'$${ORIGIN}/../../lib\''
-            ]
+            'defines': [
+              '_GLIBCXX_USE_CXX11_ABI=1'
+            ],
+            'link_settings': {
+              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
+              'libraries': [
+                '-l:libvips-cpp.so.42'
+              ],
+              'ldflags': [
+                # Ensure runtime linking is relative to sharp.node
+                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../<(sharp_vendor_dir)/lib\''
+              ]
+            }
           }]
         ]
       }]
@@ -112,80 +175,60 @@
       '-std=c++0x',
       '-fexceptions',
       '-Wall',
-      '-O3'
+      '-Os'
     ],
     'xcode_settings': {
       'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
-      'CLANG_CXX_LIBRARY': 'libc++',
-      'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      'MACOSX_DEPLOYMENT_TARGET': '10.9',
+      'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      'GCC_ENABLE_CPP_RTTI': 'YES',
       'OTHER_CPLUSPLUSFLAGS': [
         '-fexceptions',
         '-Wall',
-        '-O3'
+        '-Oz'
       ]
     },
     'configurations': {
       'Release': {
-        'msvs_settings': {
-          'VCCLCompilerTool': {
-            'ExceptionHandling': 1
-          }
-        }
+        'conditions': [
+          ['OS == "linux"', {
+            'cflags_cc': [
+              '-Wno-cast-function-type'
+            ]
+          }],
+          ['target_arch == "arm"', {
+            'cflags_cc': [
+              '-Wno-psabi'
+            ]
+          }],
+          ['OS == "win"', {
+            'msvs_settings': {
+              'VCCLCompilerTool': {
+                'ExceptionHandling': 1,
+                'Optimization': 1,
+                'WholeProgramOptimization': 'true'
+              },
+              'VCLibrarianTool': {
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false',
+                'OptimizeReferences': 2,
+                'EnableCOMDATFolding': 2,
+                'LinkIncremental': 1,
+                'AdditionalOptions': [
+                  '/LTCG:INCREMENTAL'
+                ]
+              }
+            },
+            'msvs_disabled_warnings': [
+              4275
+            ]
+          }]
+        ]
       }
     },
-  }, {
-    'target_name': 'win_copy_dlls',
-    'type': 'none',
-    'dependencies': [
-      'sharp'
-    ],
-    'conditions': [
-      ['OS == "win"', {
-        # Windows lacks support for rpath
-        'copies': [{
-          'destination': '<(module_root_dir)/build/Release',
-          'files': [
-            '<(module_root_dir)/lib/GNU.Gettext.dll',
-            '<(module_root_dir)/lib/libMagickCore-6.Q16-2.dll',
-            '<(module_root_dir)/lib/libMagickWand-6.Q16-2.dll',
-            '<(module_root_dir)/lib/libasprintf-0.dll',
-            '<(module_root_dir)/lib/libcairo-2.dll',
-            '<(module_root_dir)/lib/libcairo-gobject-2.dll',
-            '<(module_root_dir)/lib/libcairo-script-interpreter-2.dll',
-            '<(module_root_dir)/lib/libexif-12.dll',
-            '<(module_root_dir)/lib/libexpat-1.dll',
-            '<(module_root_dir)/lib/libffi-6.dll',
-            '<(module_root_dir)/lib/libfftw3-3.dll',
-            '<(module_root_dir)/lib/libfontconfig-1.dll',
-            '<(module_root_dir)/lib/libfreetype-6.dll',
-            '<(module_root_dir)/lib/libgcc_s_seh-1.dll',
-            '<(module_root_dir)/lib/libgdk_pixbuf-2.0-0.dll',
-            '<(module_root_dir)/lib/libgio-2.0-0.dll',
-            '<(module_root_dir)/lib/libglib-2.0-0.dll',
-            '<(module_root_dir)/lib/libgmodule-2.0-0.dll',
-            '<(module_root_dir)/lib/libgobject-2.0-0.dll',
-            '<(module_root_dir)/lib/libgsf-1-114.dll',
-            '<(module_root_dir)/lib/libgthread-2.0-0.dll',
-            '<(module_root_dir)/lib/libintl-8.dll',
-            '<(module_root_dir)/lib/libjpeg-62.dll',
-            '<(module_root_dir)/lib/liblcms2-2.dll',
-            '<(module_root_dir)/lib/libopenjpeg-1.dll',
-            '<(module_root_dir)/lib/libopenslide-0.dll',
-            '<(module_root_dir)/lib/libpango-1.0-0.dll',
-            '<(module_root_dir)/lib/libpangocairo-1.0-0.dll',
-            '<(module_root_dir)/lib/libpangowin32-1.0-0.dll',
-            '<(module_root_dir)/lib/libpixman-1-0.dll',
-            '<(module_root_dir)/lib/libpng16-16.dll',
-            '<(module_root_dir)/lib/libquadmath-0.dll',
-            '<(module_root_dir)/lib/libsqlite3-0.dll',
-            '<(module_root_dir)/lib/libssp-0.dll',
-            '<(module_root_dir)/lib/libtiff-5.dll',
-            '<(module_root_dir)/lib/libvips-42.dll',
-            '<(module_root_dir)/lib/libxml2-2.dll',
-            '<(module_root_dir)/lib/zlib1.dll'
-          ]
-        }]
-      }]
-    ]
   }]
 }

binding.js

@@ -1,127 +0,0 @@
-'use strict';
-
-var fs = require('fs');
-var path = require('path');
-var zlib = require('zlib');
-
-var semver = require('semver');
-var request = require('request');
-var tar = require('tar');
-
-var tmp = require('os').tmpdir();
-
-var distBaseUrl = 'https://dl.bintray.com/lovell/sharp/';
-
-var vipsHeaderPath = path.join(__dirname, 'include', 'vips', 'vips.h');
-
-// -- Helpers
-
-// Does this file exist?
-var isFile = function(file) {
-  var exists = false;
-  try {
-    exists = fs.statSync(file).isFile();
-  } catch (err) {}
-  return exists;
-};
-
-var unpack = function(tarPath, done) {
-  var extractor = tar.Extract({
-    path: __dirname
-  });
-  extractor.on('error', error);
-  extractor.on('end', function() {
-    if (!isFile(vipsHeaderPath)) {
-      error('Could not unpack ' + tarPath);
-    }
-    if (typeof done === 'function') {
-      done();
-    }
-  });
-  fs.createReadStream(tarPath).on('error', error)
-    .pipe(zlib.Unzip())
-    .pipe(extractor);
-};
-
-// Error
-var error = function(msg) {
-  if (msg instanceof Error) {
-    msg = msg.message;
-  }
-  process.stderr.write('ERROR: ' + msg + '\n');
-  process.exit(1);
-};
-
-// -- Binary downloaders
-
-module.exports.download_vips = function() {
-  // Has vips been installed locally?
-  if (!isFile(vipsHeaderPath)) {
-    // Ensure Intel 64-bit or ARM
-    if (process.arch === 'ia32') {
-      error('Intel Architecture 32-bit systems require manual installation - please see http://sharp.dimens.io/en/stable/install/');
-    }
-    // Ensure libc >= 2.15
-    var lddVersion = process.env.LDD_VERSION;
-    if (lddVersion) {
-      var libcVersion = lddVersion ? lddVersion.split(/\n/)[0].split(' ').slice(-1)[0].trim() : '';
-      if (libcVersion && semver.lt(libcVersion + '.0', '2.13.0')) {
-        error('libc version ' + libcVersion + ' requires manual installation - please see http://sharp.dimens.io/en/stable/install/');
-      }
-    }
-    // Arch/platform-specific .tar.gz
-    var platform = (process.arch === 'arm') ? 'arm' : process.platform.substr(0, 3);
-    var tarFilename = ['libvips', process.env.npm_package_config_libvips, platform].join('-') + '.tar.gz';
-    var tarPath = path.join(__dirname, 'packaging', tarFilename);
-    if (isFile(tarPath)) {
-      unpack(tarPath);
-    } else {
-      // Download to per-process temporary file
-      tarPath = path.join(tmp, process.pid + '-' + tarFilename);
-      var tmpFile = fs.createWriteStream(tarPath).on('finish', function() {
-        unpack(tarPath, function() {
-          // Attempt to remove temporary file
-          try {
-            fs.unlinkSync(tarPath);
-          } catch (err) {}
-        });
-      });
-      var options = {
-        url: distBaseUrl + tarFilename
-      };
-      if (process.env.npm_config_https_proxy) {
-        // Use the NPM-configured HTTPS proxy
-        options.proxy = process.env.npm_config_https_proxy;
-      }
-      request(options).on('response', function(response) {
-        if (response.statusCode !== 200) {
-          error(distBaseUrl + tarFilename + ' status code ' + response.statusCode);
-        }
-      }).on('error', function(err) {
-        error('Download from ' + distBaseUrl + tarFilename + ' failed: ' + err.message);
-      }).pipe(tmpFile);
-    }
-  }
-};
-
-module.exports.use_global_vips = function() {
-  var useGlobalVips = false;
-  var globalVipsVersion = process.env.GLOBAL_VIPS_VERSION;
-  if (globalVipsVersion) {
-    useGlobalVips = semver.gte(
-      globalVipsVersion,
-      process.env.npm_package_config_libvips
-    );
-  }
-  if (process.platform === 'darwin' && !useGlobalVips) {
-    if (globalVipsVersion) {
-      error(
-        'Found libvips ' + globalVipsVersion + ' but require ' + process.env.npm_package_config_libvips +
-        '\nPlease upgrade libvips by running: brew update && brew upgrade'
-      );
-    } else {
-      error('Please install libvips by running: brew install homebrew/science/vips --with-webp --with-graphicsmagick');
-    }
-  }
-  process.stdout.write(useGlobalVips ? 'true' : 'false');
-};

circle.yml

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

docs/README.md

@@ -0,0 +1,88 @@
+# sharp
+
+<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
+
+The typical use case for this high speed Node.js module
+is to convert large images in common formats to
+smaller, web-friendly JPEG, PNG, WebP, GIF and AVIF images of varying dimensions.
+
+Resizing an image is typically 4x-5x faster than using the
+quickest ImageMagick and GraphicsMagick settings
+due to its use of [libvips](https://github.com/libvips/libvips).
+
+Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
+Lanczos resampling ensures quality is not sacrificed for speed.
+
+As well as image resizing, operations such as
+rotation, extraction, compositing and gamma correction are available.
+
+Most modern macOS, Windows and Linux systems running Node.js >= 14.15.0
+do not require any additional install or runtime dependencies.
+
+### Formats
+
+This module supports reading JPEG, PNG, WebP, GIF, AVIF, TIFF and SVG images.
+
+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.
+
+A single input Stream can be split into multiple processing pipelines and output Streams.
+
+Deep Zoom image pyramids can be generated,
+suitable for use with "slippy map" tile viewers like
+[OpenSeadragon](https://github.com/openseadragon/openseadragon).
+
+### Fast
+
+This module is powered by the blazingly fast
+[libvips](https://github.com/libvips/libvips) image processing library,
+originally created in 1989 at Birkbeck College
+and currently maintained by a small team led by
+[John Cupitt](https://github.com/jcupitt).
+
+Only small regions of uncompressed image data
+are held in memory and processed at a time,
+taking full advantage of multiple CPU cores and L1/L2/L3 cache.
+
+Everything remains non-blocking thanks to _libuv_,
+no child processes are spawned and Promises/async/await are supported.
+
+### Optimal
+
+The features of `mozjpeg` and `pngquant` can be used
+to optimise the file size of JPEG and PNG images respectively,
+without having to invoke separate `imagemin` processes.
+
+Huffman tables are optimised when generating JPEG output images
+without having to use separate command line tools like
+[jpegoptim](https://github.com/tjko/jpegoptim) and
+[jpegtran](http://jpegclub.org/jpegtran/).
+
+PNG filtering is disabled by default,
+which for diagrams and line art often produces the same result
+as [pngcrush](https://pmt.sourceforge.io/pngcrush/).
+
+The file size of animated GIF output is optimised
+without having to use separate command line tools such as
+[gifsicle](https://www.lcdf.org/gifsicle/).
+
+### Contributing
+
+A [guide for contributors](https://github.com/lovell/sharp/blob/main/.github/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
+
+### Licensing
+
+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.
+You may obtain a copy of the License at
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

docs/api-channel.md

@@ -0,0 +1,145 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## removeAlpha
+
+Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
+
+See also [flatten][1].
+
+### Examples
+
+```javascript
+sharp('rgba.png')
+  .removeAlpha()
+  .toFile('rgb.png', function(err, info) {
+    // rgb.png is a 3 channel image without an alpha channel
+  });
+```
+
+Returns **Sharp**&#x20;
+
+## ensureAlpha
+
+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
+// rgba.png will be a 4 channel image with a fully-opaque alpha channel
+await sharp('rgb.jpg')
+  .ensureAlpha()
+  .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**&#x20;
+
+**Meta**
+
+*   **since**: 0.21.2
+
+## extractChannel
+
+Extract a single channel from a multi-channel image.
+
+### Parameters
+
+*   `channel` **([number][2] | [string][4])** zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
+
+### Examples
+
+```javascript
+// green.jpg is a greyscale image containing the green channel of the input
+await sharp(input)
+  .extractChannel('green')
+  .toFile('green.jpg');
+```
+
+```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**&#x20;
+
+## joinChannel
+
+Join one or more channels to the image.
+The meaning of the added channels depends on the output colourspace, set with `toColourspace()`.
+By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+Channel ordering follows vips convention:
+
+*   sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
+*   CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
+
+Buffers may be any of the image formats supported by sharp.
+For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
+
+### Parameters
+
+*   `images` **([Array][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
+
+Returns **Sharp**&#x20;
+
+## bandbool
+
+Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+
+### Parameters
+
+*   `boolOp` **[string][4]** one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+
+### Examples
+
+```javascript
+sharp('3-channel-rgb-input.png')
+  .bandbool(sharp.bool.and)
+  .toFile('1-channel-output.png', function (err, info) {
+    // The output will be a single channel image where each pixel `P = R & G & B`.
+    // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
+    // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+  });
+```
+
+*   Throws **[Error][3]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+[1]: /api-operation#flatten
+
+[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/String
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[6]: https://nodejs.org/api/buffer.html
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-colour.md

@@ -0,0 +1,150 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## tint
+
+Tint the image using the provided chroma while preserving the image luminance.
+An alpha channel may be present and will be unchanged by the operation.
+
+### Parameters
+
+*   `rgb` **([string][1] | [Object][2])** parsed by the [color][3] module to extract chroma values.
+
+### Examples
+
+```javascript
+const output = await sharp(input)
+  .tint({ r: 255, g: 240, b: 16 })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid parameter
+
+Returns **Sharp**&#x20;
+
+## greyscale
+
+Convert to 8-bit greyscale; 256 shades of grey.
+This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
+By default the output image will be web-friendly sRGB and contain three (identical) color channels.
+This may be overridden by other sharp operations such as `toColourspace('b-w')`,
+which will produce an output image containing one color channel.
+An alpha channel may be present, and will be unchanged by the operation.
+
+### Parameters
+
+*   `greyscale` **[Boolean][5]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).greyscale().toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## grayscale
+
+Alternative spelling of `greyscale`.
+
+### Parameters
+
+*   `grayscale` **[Boolean][5]**  (optional, default `true`)
+
+Returns **Sharp**&#x20;
+
+## 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**&#x20;
+
+**Meta**
+
+*   **since**: 0.29.0
+
+## pipelineColorspace
+
+Alternative spelling of `pipelineColourspace`.
+
+### Parameters
+
+*   `colorspace` **[string][1]?** pipeline colorspace.
+
+<!---->
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## toColourspace
+
+Set the output colourspace.
+By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+
+### Parameters
+
+*   `colourspace` **[string][1]?** output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][8]
+
+### Examples
+
+```javascript
+// Output 16 bits per pixel RGB
+await sharp(input)
+ .toColourspace('rgb16')
+ .toFile('16-bpp.png')
+```
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## toColorspace
+
+Alternative spelling of `toColourspace`.
+
+### Parameters
+
+*   `colorspace` **[string][1]?** output colorspace.
+
+<!---->
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[3]: https://www.npmjs.org/package/color
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[6]: #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

@@ -0,0 +1,127 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## composite
+
+Composite image(s) over the processed (resized, extracted etc.) image.
+
+The images to composite must be the same size or smaller than the processed image.
+If both `top` and `left` options are provided, they take precedence over `gravity`.
+
+Any resize or rotate operations in the same processing pipeline
+will always be applied to the input image before composition.
+
+The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+`dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+`xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+`colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+`hard-light`, `soft-light`, `difference`, `exclusion`.
+
+More information about blend modes can be found at
+[https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode][1]
+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]?**&#x20;
+            *   `images[].input.create.height` **[Number][7]?**&#x20;
+            *   `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[].input.text` **[Object][4]?** describes a new text image to be created.
+
+            *   `images[].input.text.text` **[string][6]?** text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+            *   `images[].input.text.font` **[string][6]?** font name to render with.
+            *   `images[].input.text.fontfile` **[string][6]?** absolute filesystem path to a font file that can be used by `font`.
+            *   `images[].input.text.width` **[number][7]** integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries. (optional, default `0`)
+            *   `images[].input.text.height` **[number][7]** integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0. (optional, default `0`)
+            *   `images[].input.text.align` **[string][6]** text alignment (`'left'`, `'centre'`, `'center'`, `'right'`). (optional, default `'left'`)
+            *   `images[].input.text.justify` **[boolean][9]** set this to true to apply justification to the text. (optional, default `false`)
+            *   `images[].input.text.dpi` **[number][7]** the resolution (size) at which to render the text. Does not take effect if `height` is specified. (optional, default `72`)
+            *   `images[].input.text.rgba` **[boolean][9]** set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`. (optional, default `false`)
+            *   `images[].input.text.spacing` **[number][7]** text line height in points. Will use the font line height if none is specified. (optional, default `0`)
+    *   `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]?**&#x20;
+        *   `images[].raw.height` **[Number][7]?**&#x20;
+        *   `images[].raw.channels` **[Number][7]?**&#x20;
+    *   `images[].animated` **[boolean][9]** Set to `true` to read all frames/pages of an animated image. (optional, default `false`)
+    *   `images[].failOn` **[string][6]** @see [constructor parameters][10] (optional, default `'warning'`)
+    *   `images[].limitInputPixels` **([number][7] | [boolean][9])** @see [constructor parameters][10] (optional, default `268402689`)
+
+### Examples
+
+```javascript
+await sharp(background)
+  .composite([
+    { input: layer1, gravity: 'northwest' },
+    { input: layer2, gravity: 'southeast' },
+  ])
+  .toFile('combined.png');
+```
+
+```javascript
+const output = await sharp('input.gif', { animated: true })
+  .composite([
+    { input: 'overlay.png', tile: true, blend: 'saturate' }
+  ])
+  .toBuffer();
+```
+
+```javascript
+sharp('input.png')
+  .rotate(180)
+  .resize(300)
+  .flatten( { background: '#ff6600' } )
+  .composite([{ input: 'overlay.png', gravity: 'southeast' }])
+  .sharpen()
+  .withMetadata()
+  .webp( { quality: 90 } )
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains upside down, 300px wide, alpha channel flattened
+    // onto orange background, composited with overlay.png with SE gravity,
+    // sharpened, with metadata, 90% quality WebP image data. Phew!
+  });
+```
+
+*   Throws **[Error][11]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.22.0
+
+[1]: https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode
+
+[2]: https://www.cairographics.org/operators/
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[5]: https://nodejs.org/api/buffer.html
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[8]: https://www.npmjs.org/package/color
+
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[10]: /api-constructor#parameters
+
+[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error

docs/api-constructor.md

@@ -0,0 +1,269 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## Sharp
+
+Constructor factory to create an instance of `sharp`, to which further methods are chained.
+
+JPEG, PNG, WebP, 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.
+
+Implements the [stream.Duplex][1] class.
+
+### Parameters
+
+*   `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.failOn` **[string][12]** level of sensitivity to invalid images, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels. (optional, default `'warning'`)
+    *   `options.limitInputPixels` **([number][14] | [boolean][15])** 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][15]** Set this to `true` to remove safety features that help prevent memory exhaustion (JPEG, PNG, SVG, HEIF). (optional, default `false`)
+    *   `options.sequentialRead` **[boolean][15]** 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][14]** number representing the DPI for vector images in the range 1 to 100000. (optional, default `72`)
+    *   `options.pages` **[number][14]** 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][14]** page number to start extracting from for multi-page input (GIF, WebP, AVIF, TIFF, PDF), zero based. (optional, default `0`)
+    *   `options.subifd` **[number][14]** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default `-1`)
+    *   `options.level` **[number][14]** level to extract from a multi-level input (OpenSlide), zero based. (optional, default `0`)
+    *   `options.animated` **[boolean][15]** 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][14]?** integral number of pixels wide.
+        *   `options.raw.height` **[number][14]?** integral number of pixels high.
+        *   `options.raw.channels` **[number][14]?** integral number of channels, between 1 and 4.
+        *   `options.raw.premultiplied` **[boolean][15]?** 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][14]?** integral number of pixels wide.
+        *   `options.create.height` **[number][14]?** integral number of pixels high.
+        *   `options.create.channels` **[number][14]?** 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][14]?** mean of pixels in generated noise.
+            *   `options.create.noise.sigma` **[number][14]?** standard deviation of pixels in generated noise.
+    *   `options.text` **[Object][13]?** describes a new text image to be created.
+
+        *   `options.text.text` **[string][12]?** text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+        *   `options.text.font` **[string][12]?** font name to render with.
+        *   `options.text.fontfile` **[string][12]?** absolute filesystem path to a font file that can be used by `font`.
+        *   `options.text.width` **[number][14]** integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries. (optional, default `0`)
+        *   `options.text.height` **[number][14]** integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0. (optional, default `0`)
+        *   `options.text.align` **[string][12]** text alignment (`'left'`, `'centre'`, `'center'`, `'right'`). (optional, default `'left'`)
+        *   `options.text.justify` **[boolean][15]** set this to true to apply justification to the text. (optional, default `false`)
+        *   `options.text.dpi` **[number][14]** the resolution (size) at which to render the text. Does not take effect if `height` is specified. (optional, default `72`)
+        *   `options.text.rgba` **[boolean][15]** set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`. (optional, default `false`)
+        *   `options.text.spacing` **[number][14]** text line height in points. Will use the font line height if none is specified. (optional, default `0`)
+
+### Examples
+
+```javascript
+sharp('input.jpg')
+  .resize(300, 200)
+  .toFile('output.jpg', function(err) {
+    // output.jpg is a 300 pixels wide and 200 pixels high image
+    // containing a scaled and cropped version of input.jpg
+  });
+```
+
+```javascript
+// Read image data from readableStream,
+// resize to 300 pixels wide,
+// emit an 'info' event with calculated dimensions
+// and finally write image data to writableStream
+var transformer = sharp()
+  .resize(300)
+  .on('info', function(info) {
+    console.log('Image height is ' + info.height);
+  });
+readableStream.pipe(transformer).pipe(writableStream);
+```
+
+```javascript
+// Create a blank 300x200 PNG image of semi-transluent red pixels
+sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 4,
+    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+  }
+})
+.png()
+.toBuffer()
+.then( ... );
+```
+
+```javascript
+// Convert an animated GIF to an animated WebP
+await sharp('in.gif', { animated: true }).toFile('out.webp');
+```
+
+```javascript
+// Read a raw array of pixels and save it to a png
+const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+const image = sharp(input, {
+  // because the input does not contain its dimensions or how many channels it has
+  // we need to specify it in the constructor options
+  raw: {
+    width: 2,
+    height: 1,
+    channels: 3
+  }
+});
+await image.toFile('my-two-pixels.png');
+```
+
+```javascript
+// Generate RGB Gaussian noise
+await sharp({
+  create: {
+    width: 300,
+    height: 200,
+    channels: 3,
+    noise: {
+      type: 'gaussian',
+      mean: 128,
+      sigma: 30
+    }
+ }
+}).toFile('noise.png');
+```
+
+```javascript
+// Generate an image from text
+await sharp({
+  text: {
+    text: 'Hello, world!',
+    width: 400, // max width
+    height: 300 // max height
+  }
+}).toFile('text_bw.png');
+```
+
+```javascript
+// Generate an rgba image from text using pango markup and font
+await sharp({
+  text: {
+    text: '<span foreground="red">Red!</span><span background="cyan">blue</span>',
+    font: 'sans',
+    rgba: true,
+    dpi: 300
+  }
+}).toFile('text_rgba.png');
+```
+
+*   Throws **[Error][17]** Invalid parameters
+
+Returns **[Sharp][18]**&#x20;
+
+## clone
+
+Take a "snapshot" of the Sharp instance, returning a new instance.
+Cloned instances inherit the input of their parent instance.
+This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
+
+### Examples
+
+```javascript
+const pipeline = sharp().rotate();
+pipeline.clone().resize(800, 600).pipe(firstWritableStream);
+pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
+readableStream.pipe(pipeline);
+// firstWritableStream receives auto-rotated, resized readableStream
+// secondWritableStream receives auto-rotated, extracted region of readableStream
+```
+
+```javascript
+// Create a pipeline that will download an image, resize it and format it to different files
+// Using Promises to know when the pipeline is complete
+const fs = require("fs");
+const got = require("got");
+const sharpStream = sharp({ failOn: 'none' });
+
+const promises = [];
+
+promises.push(
+  sharpStream
+    .clone()
+    .jpeg({ quality: 100 })
+    .toFile("originalFile.jpg")
+);
+
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .jpeg({ quality: 80 })
+    .toFile("optimized-500.jpg")
+);
+
+promises.push(
+  sharpStream
+    .clone()
+    .resize({ width: 500 })
+    .webp({ quality: 80 })
+    .toFile("optimized-500.webp")
+);
+
+// https://github.com/sindresorhus/got/blob/main/documentation/3-streams.md
+got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
+
+Promise.all(promises)
+  .then(res => { console.log("Done!", res); })
+  .catch(err => {
+    console.error("Error processing files, let's clean it up", err);
+    try {
+      fs.unlinkSync("originalFile.jpg");
+      fs.unlinkSync("optimized-500.jpg");
+      fs.unlinkSync("optimized-500.webp");
+    } catch (e) {}
+  });
+```
+
+Returns **[Sharp][18]**&#x20;
+
+[1]: http://nodejs.org/api/stream.html#stream_class_stream_duplex
+
+[2]: https://nodejs.org/api/buffer.html
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int8Array
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int16Array
+
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array
+
+[9]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Float32Array
+
+[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/Number
+
+[15]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[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

@@ -0,0 +1,149 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## metadata
+
+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.
+
+Dimensions in the response will respect the `page` and `pages` properties of the
+[constructor parameters][1].
+
+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, see example below)
+*   `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
+*   `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...][2]
+*   `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+*   `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...][3]
+*   `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][4] 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][5]?** called with the arguments `(err, metadata)`
+
+### Examples
+
+```javascript
+const metadata = await sharp(input).metadata();
+```
+
+```javascript
+const image = sharp(inputJpg);
+image
+  .metadata()
+  .then(function(metadata) {
+    return image
+      .resize(Math.round(metadata.width / 2))
+      .webp()
+      .toBuffer();
+  })
+  .then(function(data) {
+    // data contains a WebP image half the width and height of the original JPEG
+  });
+```
+
+```javascript
+// Based on EXIF rotation metadata, get the right-side-up width and height:
+
+const size = getNormalSize(await sharp(input).metadata());
+
+function getNormalSize({ width, height, orientation }) {
+  return (orientation || 0) >= 5
+    ? { width: height, height: width }
+    : { width, height };
+}
+```
+
+Returns **([Promise][6]<[Object][7]> | Sharp)**&#x20;
+
+## 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.
+*   `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any.
+*   `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram.
+
+**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][5]?** called with the arguments `(err, stats)`
+
+### Examples
+
+```javascript
+const image = sharp(inputJpg);
+image
+  .stats()
+  .then(function(stats) {
+     // stats contains the channel-wise statistics array and the isOpaque value
+  });
+```
+
+```javascript
+const { entropy, sharpness, dominant } = await sharp(input).stats();
+const { r, g, b } = dominant;
+```
+
+```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][6]<[Object][7]>**&#x20;
+
+[1]: /api-constructor#parameters
+
+[2]: https://www.libvips.org/API/current/VipsImage.html#VipsInterpretation
+
+[3]: https://www.libvips.org/API/current/VipsImage.html#VipsBandFormat
+
+[4]: https://www.npmjs.com/package/icc
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

docs/api-operation.md

@@ -0,0 +1,613 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## rotate
+
+Rotate the output image by either an explicit angle
+or auto-orient based on the EXIF `Orientation` tag.
+
+If an angle is provided, it is converted to a valid positive degree rotation.
+For example, `-450` will produce a 270deg rotation.
+
+When rotating by an angle other than a multiple of 90,
+the background colour can be provided with the `background` option.
+
+If no angle is provided, it is determined from the EXIF data.
+Mirroring is supported and may infer the use of a flip operation.
+
+The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+
+Only one rotation can occur per pipeline.
+Previous calls to `rotate` in the same pipeline will be ignored.
+
+Method order is important when rotating, resizing and/or extracting regions,
+for example `.rotate(x).extract(y)` will produce a different result to `.extract(y).rotate(x)`.
+
+### Parameters
+
+*   `angle` **[number][1]** angle of rotation. (optional, default `auto`)
+*   `options` **[Object][2]?** if present, is an Object with optional attributes.
+
+    *   `options.background` **([string][3] | [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+
+### Examples
+
+```javascript
+const pipeline = sharp()
+  .rotate()
+  .resize(null, 200)
+  .toBuffer(function (err, outputBuffer, info) {
+    // outputBuffer contains 200px high JPEG image data,
+    // auto-rotated using EXIF Orientation tag
+    // info.width and info.height contain the dimensions of the resized image
+  });
+readableStream.pipe(pipeline);
+```
+
+```javascript
+const rotateThenResize = await sharp(input)
+  .rotate(90)
+  .resize({ width: 16, height: 8, fit: 'fill' })
+  .toBuffer();
+const resizeThenRotate = await sharp(input)
+  .resize({ width: 16, height: 8, fit: 'fill' })
+  .rotate(90)
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## flip
+
+Flip the image about the vertical Y axis. This always occurs before rotation, if any.
+The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
+
+### Parameters
+
+*   `flip` **[Boolean][6]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).flip().toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## flop
+
+Flop the image about the horizontal X axis. This always occurs before rotation, if any.
+The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
+
+### Parameters
+
+*   `flop` **[Boolean][6]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).flop().toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## affine
+
+Perform an affine transform on an image. This operation will always occur after resizing, extraction and rotation, if any.
+
+You must provide an array of length 4 or a 2x2 affine transformation matrix.
+By default, new pixels are filled with a black background. You can provide a background color with the `background` option.
+A particular interpolator may also be specified. Set the `interpolator` option to an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.nohalo`.
+
+In the case of a 2x2 matrix, the transform is:
+
+*   X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
+*   Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
+
+where:
+
+*   x and y are the coordinates in input image.
+*   X and Y are the coordinates in output image.
+*   (0,0) is the upper left corner.
+
+### Parameters
+
+*   `matrix` **([Array][7]<[Array][7]<[number][1]>> | [Array][7]<[number][1]>)** affine transformation matrix
+*   `options` **[Object][2]?** if present, is an Object with optional attributes.
+
+    *   `options.background` **([String][3] | [Object][2])** parsed by the [color][4] module to extract values for red, green, blue and alpha. (optional, default `"#000000"`)
+    *   `options.idx` **[Number][1]** input horizontal offset (optional, default `0`)
+    *   `options.idy` **[Number][1]** input vertical offset (optional, default `0`)
+    *   `options.odx` **[Number][1]** output horizontal offset (optional, default `0`)
+    *   `options.ody` **[Number][1]** output vertical offset (optional, default `0`)
+    *   `options.interpolator` **[String][3]** interpolator (optional, default `sharp.interpolators.bicubic`)
+
+### Examples
+
+```javascript
+const pipeline = sharp()
+  .affine([[1, 0.3], [0.1, 0.7]], {
+     background: 'white',
+     interpolate: sharp.interpolators.nohalo
+  })
+  .toBuffer((err, outputBuffer, info) => {
+     // outputBuffer contains the transformed image
+     // info.width and info.height contain the new dimensions
+  });
+
+inputStream
+  .pipe(pipeline);
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.27.0
+
+## sharpen
+
+Sharpen the image.
+When used without parameters, performs a fast, mild sharpen of the output image.
+When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
+Separate control over the level of sharpening in "flat" and "jagged" areas is available.
+
+See [libvips sharpen][8] operation.
+
+### Parameters
+
+*   `options` **([Object][2] | [number][1])?** if present, is an Object with attributes or (deprecated) a number for `options.sigma`.
+
+    *   `options.sigma` **[number][1]?** the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
+    *   `options.m1` **[number][1]** the level of sharpening to apply to "flat" areas. (optional, default `1.0`)
+    *   `options.m2` **[number][1]** the level of sharpening to apply to "jagged" areas. (optional, default `2.0`)
+    *   `options.x1` **[number][1]** threshold between "flat" and "jagged" (optional, default `2.0`)
+    *   `options.y2` **[number][1]** maximum amount of brightening. (optional, default `10.0`)
+    *   `options.y3` **[number][1]** maximum amount of darkening. (optional, default `20.0`)
+*   `flat` **[number][1]?** (deprecated) see `options.m1`.
+*   `jagged` **[number][1]?** (deprecated) see `options.m2`.
+
+### Examples
+
+```javascript
+const data = await sharp(input).sharpen().toBuffer();
+```
+
+```javascript
+const data = await sharp(input).sharpen({ sigma: 2 }).toBuffer();
+```
+
+```javascript
+const data = await sharp(input)
+  .sharpen({
+    sigma: 2,
+    m1: 0,
+    m2: 3,
+    x1: 3,
+    y2: 15,
+    y3: 15,
+  })
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## median
+
+Apply median filter.
+When used without parameters the default window is 3x3.
+
+### Parameters
+
+*   `size` **[number][1]** square mask size: size x size (optional, default `3`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).median().toBuffer();
+```
+
+```javascript
+const output = await sharp(input).median(5).toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## blur
+
+Blur the 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`.
+
+### Examples
+
+```javascript
+const boxBlurred = await sharp(input)
+  .blur()
+  .toBuffer();
+```
+
+```javascript
+const gaussianBlurred = await sharp(input)
+  .blur(5)
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## flatten
+
+Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
+
+See also [removeAlpha][9].
+
+### Parameters
+
+*   `options` **[Object][2]?**&#x20;
+
+    *   `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({ background: '#F0A703' })
+  .toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## gamma
+
+Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma`
+then increasing the encoding (brighten) post-resize at a factor of `gamma`.
+This can improve the perceived brightness of a resized image in non-linear colour spaces.
+JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
+when applying a gamma correction.
+
+Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
+
+### Parameters
+
+*   `gamma` **[number][1]** value between 1.0 and 3.0. (optional, default `2.2`)
+*   `gammaOut` **[number][1]?** value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
+
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## negate
+
+Produce the "negative" of the image.
+
+### Parameters
+
+*   `options` **[Object][2]?**&#x20;
+
+    *   `options.alpha` **[Boolean][6]** Whether or not to negate any alpha channel (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input)
+  .negate()
+  .toBuffer();
+```
+
+```javascript
+const output = await sharp(input)
+  .negate({ alpha: false })
+  .toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## normalise
+
+Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+
+### Parameters
+
+*   `normalise` **[Boolean][6]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).normalise().toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## normalize
+
+Alternative spelling of normalise.
+
+### Parameters
+
+*   `normalize` **[Boolean][6]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const output = await sharp(input).normalize().toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+## clahe
+
+Perform contrast limiting adaptive histogram equalization
+[CLAHE][10].
+
+This will, in general, enhance the clarity of the image by bringing out darker details.
+
+### Parameters
+
+*   `options` **[Object][2]**&#x20;
+
+    *   `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`)
+
+### Examples
+
+```javascript
+const output = await sharp(input)
+  .clahe({
+    width: 3,
+    height: 3,
+  })
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.28.3
+
+## convolve
+
+Convolve the image with the specified kernel.
+
+### Parameters
+
+*   `kernel` **[Object][2]**&#x20;
+
+    *   `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
+
+```javascript
+sharp(input)
+  .convolve({
+    width: 3,
+    height: 3,
+    kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
+  })
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data representing the convolution
+    // of the input image with the horizontal Sobel operator
+  });
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## threshold
+
+Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+
+### Parameters
+
+*   `threshold` **[number][1]** a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default `128`)
+*   `options` **[Object][2]?**&#x20;
+
+    *   `options.greyscale` **[Boolean][6]** convert to single channel greyscale. (optional, default `true`)
+    *   `options.grayscale` **[Boolean][6]** alternative spelling for greyscale. (optional, default `true`)
+
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## boolean
+
+Perform a bitwise boolean operation with operand image.
+
+This operation creates an output image where each pixel is the result of
+the selected bitwise boolean `operation` between the corresponding pixels of the input images.
+
+### Parameters
+
+*   `operand` **([Buffer][11] | [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]?**&#x20;
+
+    *   `options.raw` **[Object][2]?** describes operand when using raw pixel data.
+
+        *   `options.raw.width` **[number][1]?**&#x20;
+        *   `options.raw.height` **[number][1]?**&#x20;
+        *   `options.raw.channels` **[number][1]?**&#x20;
+
+<!---->
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## linear
+
+Apply the linear formula `a` \* input + `b` to the image to adjust image levels.
+
+When a single number is provided, it will be used for all image channels.
+When an array of numbers is provided, the array length must match the number of channels.
+
+### Parameters
+
+*   `a` **([number][1] | [Array][7]<[number][1]>)** multiplier (optional, default `[]`)
+*   `b` **([number][1] | [Array][7]<[number][1]>)** offset (optional, default `[]`)
+
+### Examples
+
+```javascript
+await sharp(input)
+  .linear(0.5, 2)
+  .toBuffer();
+```
+
+```javascript
+await sharp(rgbInput)
+  .linear(
+    [0.25, 0.5, 0.75],
+    [150, 100, 50]
+  )
+  .toBuffer();
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## recomb
+
+Recomb the image with the specified matrix.
+
+### Parameters
+
+*   `inputMatrix` **[Array][7]<[Array][7]<[number][1]>>** 3x3 Recombination matrix
+
+### Examples
+
+```javascript
+sharp(input)
+  .recomb([
+   [0.3588, 0.7044, 0.1368],
+   [0.2990, 0.5870, 0.1140],
+   [0.2392, 0.4696, 0.0912],
+  ])
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data after applying the recomb
+    // With this example input, a sepia filter has been applied
+  });
+```
+
+*   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.21.1
+
+## modulate
+
+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]?**&#x20;
+
+    *   `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
+// increase brightness by a factor of 2
+const output = await sharp(input)
+  .modulate({
+    brightness: 2
+  })
+  .toBuffer();
+```
+
+```javascript
+// hue-rotate by 180 degrees
+const output = await sharp(input)
+  .modulate({
+    hue: 180
+  })
+  .toBuffer();
+```
+
+```javascript
+// increase lightness by +50
+const output = await sharp(input)
+  .modulate({
+    lightness: 50
+  })
+  .toBuffer();
+```
+
+```javascript
+// decreate brightness and saturation while also hue-rotating by 90 degrees
+const output = await sharp(input)
+  .modulate({
+    brightness: 0.5,
+    saturation: 0.5,
+    hue: 90,
+  })
+  .toBuffer();
+```
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.22.1
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[4]: https://www.npmjs.org/package/color
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[8]: https://www.libvips.org/API/current/libvips-convolution.html#vips-sharpen
+
+[9]: /api-channel#removealpha
+
+[10]: https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_AHE
+
+[11]: https://nodejs.org/api/buffer.html

docs/api-output.md

@@ -0,0 +1,682 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## toFile
+
+Write output image data to a file.
+
+If an explicit output format is not selected, it will be inferred from the extension,
+with JPEG, PNG, WebP, AVIF, TIFF, 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)`.
+    `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`.
+    May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
+
+### Examples
+
+```javascript
+sharp(input)
+  .toFile('output.png', (err, info) => { ... });
+```
+
+```javascript
+sharp(input)
+  .toFile('output.png')
+  .then(info => { ... })
+  .catch(err => { ... });
+```
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **[Promise][5]<[Object][6]>** when no callback is provided
+
+## toBuffer
+
+Write output to a Buffer.
+JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
+
+Use [toFormat][7] or one of the format-specific functions such as [jpeg][8], [png][9] etc. to set the output format.
+
+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`.
+    May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
+
+A `Promise` is returned when `callback` is not provided.
+
+### Parameters
+
+*   `options` **[Object][6]?**&#x20;
+
+    *   `options.resolveWithObject` **[boolean][10]?** Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
+*   `callback` **[Function][3]?**&#x20;
+
+### Examples
+
+```javascript
+sharp(input)
+  .toBuffer((err, data, info) => { ... });
+```
+
+```javascript
+sharp(input)
+  .toBuffer()
+  .then(data => { ... })
+  .catch(err => { ... });
+```
+
+```javascript
+sharp(input)
+  .png()
+  .toBuffer({ resolveWithObject: true })
+  .then(({ data, info }) => { ... })
+  .catch(err => { ... });
+```
+
+```javascript
+const { data, info } = await sharp('my-image.jpg')
+  // output the raw pixels
+  .raw()
+  .toBuffer({ resolveWithObject: true });
+
+// create a more type safe way to work with the raw pixel data
+// this will not copy the data, instead it will change `data`s underlying ArrayBuffer
+// so `data` and `pixelArray` point to the same memory location
+const pixelArray = new Uint8ClampedArray(data.buffer);
+
+// When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
+const { width, height, channels } = info;
+await sharp(pixelArray, { raw: { width, height, channels } })
+  .toFile('my-changed-image.jpg');
+```
+
+Returns **[Promise][5]<[Buffer][11]>** when no callback is provided
+
+## withMetadata
+
+Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
+This will also convert to and add a web-friendly sRGB ICC profile unless a custom
+output profile is provided.
+
+The default behaviour, when `withMetadata` is not used, is to convert to the device-independent
+sRGB colour space and strip all metadata, including the removal of any ICC profile.
+
+EXIF metadata is unsupported for TIFF output.
+
+### Parameters
+
+*   `options` **[Object][6]?**&#x20;
+
+    *   `options.orientation` **[number][12]?** 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][12]?** Number of pixels per inch (DPI).
+
+### Examples
+
+```javascript
+sharp('input.jpg')
+  .withMetadata()
+  .toFile('output-with-metadata.jpg')
+  .then(info => { ... });
+```
+
+```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**&#x20;
+
+## toFormat
+
+Force output to a given format.
+
+### Parameters
+
+*   `format` **([string][2] | [Object][6])** as a string or an Object with an 'id' attribute
+*   `options` **[Object][6]** output options
+
+### Examples
+
+```javascript
+// Convert any input to PNG output
+const data = await sharp(input)
+  .toFormat('png')
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** unsupported format or options
+
+Returns **Sharp**&#x20;
+
+## jpeg
+
+Use these JPEG options for output image.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.progressive` **[boolean][10]** 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][10]** optimise Huffman coding tables (optional, default `true`)
+    *   `options.optimizeCoding` **[boolean][10]** alternative spelling of optimiseCoding (optional, default `true`)
+    *   `options.mozjpeg` **[boolean][10]** use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }` (optional, default `false`)
+    *   `options.trellisQuantisation` **[boolean][10]** apply trellis quantisation (optional, default `false`)
+    *   `options.overshootDeringing` **[boolean][10]** apply overshoot deringing (optional, default `false`)
+    *   `options.optimiseScans` **[boolean][10]** optimise progressive scans, forces progressive (optional, default `false`)
+    *   `options.optimizeScans` **[boolean][10]** alternative spelling of optimiseScans (optional, default `false`)
+    *   `options.quantisationTable` **[number][12]** quantization table to use, integer 0-8 (optional, default `0`)
+    *   `options.quantizationTable` **[number][12]** alternative spelling of quantisationTable (optional, default `0`)
+    *   `options.force` **[boolean][10]** force JPEG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to very high quality JPEG output
+const data = await sharp(input)
+  .jpeg({
+    quality: 100,
+    chromaSubsampling: '4:4:4'
+  })
+  .toBuffer();
+```
+
+```javascript
+// Use mozjpeg to reduce output JPEG file size (slower)
+const data = await sharp(input)
+  .jpeg({ mozjpeg: true })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+## png
+
+Use these PNG options for output image.
+
+By default, PNG output is full colour at 8 or 16 bits per pixel.
+Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
+Set `palette` to `true` for slower, indexed PNG output.
+
+### Parameters
+
+*   `options` **[Object][6]?**&#x20;
+
+    *   `options.progressive` **[boolean][10]** use progressive (interlace) scan (optional, default `false`)
+    *   `options.compressionLevel` **[number][12]** zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest) (optional, default `6`)
+    *   `options.adaptiveFiltering` **[boolean][10]** use adaptive row filtering (optional, default `false`)
+    *   `options.palette` **[boolean][10]** quantise to a palette-based image with alpha transparency support (optional, default `false`)
+    *   `options.quality` **[number][12]** use the lowest number of colours needed to achieve given quality, sets `palette` to `true` (optional, default `100`)
+    *   `options.effort` **[number][12]** CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true` (optional, default `7`)
+    *   `options.colours` **[number][12]** maximum number of palette entries, sets `palette` to `true` (optional, default `256`)
+    *   `options.colors` **[number][12]** alternative spelling of `options.colours`, sets `palette` to `true` (optional, default `256`)
+    *   `options.dither` **[number][12]** level of Floyd-Steinberg error diffusion, sets `palette` to `true` (optional, default `1.0`)
+    *   `options.force` **[boolean][10]** force PNG output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to full colour PNG output
+const data = await sharp(input)
+  .png()
+  .toBuffer();
+```
+
+```javascript
+// Convert any input to indexed PNG output (slower)
+const data = await sharp(input)
+  .png({ palette: true })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+## webp
+
+Use these WebP options for output image.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.alphaQuality` **[number][12]** quality of alpha layer, integer 0-100 (optional, default `100`)
+    *   `options.lossless` **[boolean][10]** use lossless compression mode (optional, default `false`)
+    *   `options.nearLossless` **[boolean][10]** use near\_lossless compression mode (optional, default `false`)
+    *   `options.smartSubsample` **[boolean][10]** use high quality chroma subsampling (optional, default `false`)
+    *   `options.effort` **[number][12]** CPU effort, between 0 (fastest) and 6 (slowest) (optional, default `4`)
+    *   `options.loop` **[number][12]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][12] | [Array][13]<[number][12]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.minSize` **[boolean][10]** prevent use of animation key frames to minimise file size (slow) (optional, default `false`)
+    *   `options.mixed` **[boolean][10]** allow mixture of lossy and lossless animation frames (slow) (optional, default `false`)
+    *   `options.force` **[boolean][10]** force WebP output, otherwise attempt to use input format (optional, default `true`)
+
+### Examples
+
+```javascript
+// Convert any input to lossless WebP output
+const data = await sharp(input)
+  .webp({ lossless: true })
+  .toBuffer();
+```
+
+```javascript
+// Optimise the file size of an animated WebP
+const outputWebp = await sharp(inputWebp, { animated: true })
+  .webp({ effort: 6 })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+## gif
+
+Use these GIF options for the output image.
+
+The first entry in the palette is reserved for transparency.
+
+The palette of the input image will be re-used if possible.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.reoptimise` **[boolean][10]** always generate new palettes (slow), re-use existing by default (optional, default `false`)
+    *   `options.reoptimize` **[boolean][10]** alternative spelling of `options.reoptimise` (optional, default `false`)
+    *   `options.colours` **[number][12]** maximum number of palette entries, including transparency, between 2 and 256 (optional, default `256`)
+    *   `options.colors` **[number][12]** alternative spelling of `options.colours` (optional, default `256`)
+    *   `options.effort` **[number][12]** CPU effort, between 1 (fastest) and 10 (slowest) (optional, default `7`)
+    *   `options.dither` **[number][12]** level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default `1.0`)
+    *   `options.loop` **[number][12]** number of animation iterations, use 0 for infinite animation (optional, default `0`)
+    *   `options.delay` **([number][12] | [Array][13]<[number][12]>)?** delay(s) between animation frames (in milliseconds)
+    *   `options.force` **[boolean][10]** 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**&#x20;
+
+**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][14].
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.lossless` **[boolean][10]** use lossless compression mode (optional, default `false`)
+    *   `options.tileWidth` **[number][12]** horizontal tile size (optional, default `512`)
+    *   `options.tileHeight` **[number][12]** vertical tile size (optional, default `512`)
+    *   `options.chromaSubsampling` **[string][2]** set to '4:2:0' to use chroma subsampling (optional, default `'4:4:4'`)
+
+### 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**&#x20;
+
+**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][12]** quality, integer 1-100 (optional, default `80`)
+    *   `options.force` **[boolean][10]** force TIFF output, otherwise attempt to use input format (optional, default `true`)
+    *   `options.compression` **[string][2]** compression options: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k (optional, default `'jpeg'`)
+    *   `options.predictor` **[string][2]** compression predictor options: none, horizontal, float (optional, default `'horizontal'`)
+    *   `options.pyramid` **[boolean][10]** write an image pyramid (optional, default `false`)
+    *   `options.tile` **[boolean][10]** write a tiled tiff (optional, default `false`)
+    *   `options.tileWidth` **[number][12]** horizontal tile size (optional, default `256`)
+    *   `options.tileHeight` **[number][12]** vertical tile size (optional, default `256`)
+    *   `options.xres` **[number][12]** horizontal resolution in pixels/mm (optional, default `1.0`)
+    *   `options.yres` **[number][12]** vertical resolution in pixels/mm (optional, default `1.0`)
+    *   `options.resolutionUnit` **[string][2]** resolution unit options: inch, cm (optional, default `'inch'`)
+    *   `options.bitdepth` **[number][12]** reduce bitdepth to 1, 2 or 4 bit (optional, default `8`)
+
+### Examples
+
+```javascript
+// Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
+sharp('input.svg')
+  .tiff({
+    compression: 'lzw',
+    bitdepth: 1
+  })
+  .toFile('1-bpp-output.tiff')
+  .then(info => { ... });
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+## avif
+
+Use these AVIF options for output image.
+
+Whilst it is possible to create AVIF images smaller than 16x16 pixels,
+most web browsers do not display these properly.
+
+AVIF image sequences are not supported.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `50`)
+    *   `options.lossless` **[boolean][10]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][12]** 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'`)
+
+### Examples
+
+```javascript
+const data = await sharp(input)
+  .avif({ effort: 2 })
+  .toBuffer();
+```
+
+```javascript
+const data = await sharp(input)
+  .avif({ lossless: true })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.27.0
+
+## heif
+
+Use these HEIF options for output image.
+
+Support for patent-encumbered HEIC images using `hevc` compression requires the use of a
+globally-installed libvips compiled with support for libheif, libde265 and x265.
+
+### Parameters
+
+*   `options` **[Object][6]?** output options
+
+    *   `options.quality` **[number][12]** quality, integer 1-100 (optional, default `50`)
+    *   `options.compression` **[string][2]** compression format: av1, hevc (optional, default `'av1'`)
+    *   `options.lossless` **[boolean][10]** use lossless compression (optional, default `false`)
+    *   `options.effort` **[number][12]** 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'`)
+
+### Examples
+
+```javascript
+const data = await sharp(input)
+  .heif({ compression: 'hevc' })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.23.0
+
+## raw
+
+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, 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, unsigned 16-bit pixel data from PNG input
+const data = await sharp('input.png')
+  .ensureAlpha()
+  .extractChannel(3)
+  .toColourspace('b-w')
+  .raw({ depth: 'ushort' })
+  .toBuffer();
+```
+
+*   Throws **[Error][4]** Invalid options
+
+## tile
+
+Use tile-based deep zoom (image pyramid) output.
+
+Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
+Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
+
+The container will be set to `zip` when the output is a Buffer or Stream, otherwise it will default to `fs`.
+
+### Parameters
+
+*   `options` **[Object][6]?**&#x20;
+
+    *   `options.size` **[number][12]** tile size in pixels, a value between 1 and 8192. (optional, default `256`)
+    *   `options.overlap` **[number][12]** tile overlap in pixels, a value between 0 and 8192. (optional, default `0`)
+    *   `options.angle` **[number][12]** 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][15] 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][12]** 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][10]** centre image in tile. (optional, default `false`)
+    *   `options.center` **[boolean][10]** 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'`)
+    *   `options.basename` **[string][2]?** the name of the directory within the zip file when container is `zip`.
+
+### Examples
+
+```javascript
+sharp('input.tiff')
+  .png()
+  .tile({
+    size: 512
+  })
+  .toFile('output.dz', function(err, info) {
+    // output.dzi is the Deep Zoom XML definition
+    // output_files contains 512x512 tiles grouped by zoom level
+  });
+```
+
+```javascript
+const zipFileWithTiles = await sharp(input)
+  .tile({ basename: "tiles" })
+  .toBuffer();
+```
+
+```javascript
+const iiififier = sharp().tile({ layout: "iiif" });
+readableStream
+  .pipe(iiififier)
+  .pipe(writeableStream);
+```
+
+*   Throws **[Error][4]** Invalid parameters
+
+Returns **Sharp**&#x20;
+
+## 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]**&#x20;
+
+    *   `options.seconds` **[number][12]** Number of seconds after which processing will be stopped
+
+### Examples
+
+```javascript
+// Ensure processing takes no longer than 3 seconds
+try {
+  const data = await sharp(input)
+    .blur(1000)
+    .timeout({ seconds: 3 })
+    .toBuffer();
+} catch (err) {
+  if (err.message.includes('timeout')) { ... }
+}
+```
+
+Returns **Sharp**&#x20;
+
+**Meta**
+
+*   **since**: 0.29.2
+
+[1]: #withmetadata
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[7]: #toformat
+
+[8]: #jpeg
+
+[9]: #png
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[11]: https://nodejs.org/api/buffer.html
+
+[12]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[13]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+[14]: https://sharp.pixelplumbing.com/install#custom-libvips
+
+[15]: https://www.npmjs.org/package/color

docs/api-resize.md

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

docs/api-utility.md

@@ -0,0 +1,216 @@
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## format
+
+An Object containing nested boolean values representing the available input and output formats/methods.
+
+### Examples
+
+```javascript
+console.log(sharp.format);
+```
+
+Returns **[Object][1]**&#x20;
+
+## interpolators
+
+An Object containing the available interpolators and their proper values
+
+Type: [string][2]
+
+### nearest
+
+[Nearest neighbour interpolation][3]. Suitable for image enlargement only.
+
+### bilinear
+
+[Bilinear interpolation][4]. Faster than bicubic but with less smooth results.
+
+### bicubic
+
+[Bicubic interpolation][5] (the default).
+
+### locallyBoundedBicubic
+
+[LBB interpolation][6]. Prevents some "[acutance][7]" but typically reduces performance by a factor of 2.
+
+### nohalo
+
+[Nohalo interpolation][8]. Prevents acutance but typically reduces performance by a factor of 3.
+
+### vertexSplitQuadraticBasisSpline
+
+[VSQBS interpolation][9]. Prevents "staircasing" when enlarging.
+
+## versions
+
+An Object containing the version numbers of libvips and its dependencies.
+
+### Examples
+
+```javascript
+console.log(sharp.versions);
+```
+
+## 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.
+Existing entries in the cache will be trimmed after any change in limits.
+This method always returns cache statistics,
+useful for determining how much working memory is required for a particular task.
+
+### Parameters
+
+*   `options` **([Object][1] | [boolean][10])** Object with the following attributes, or boolean where true uses default cache settings and false removes all caching (optional, default `true`)
+
+    *   `options.memory` **[number][11]** is the maximum memory in MB to use for this cache (optional, default `50`)
+    *   `options.files` **[number][11]** is the maximum number of files to hold open (optional, default `20`)
+    *   `options.items` **[number][11]** is the maximum number of operations to cache (optional, default `100`)
+
+### Examples
+
+```javascript
+const stats = sharp.cache();
+```
+
+```javascript
+sharp.cache( { items: 200 } );
+sharp.cache( { files: 0 } );
+sharp.cache(false);
+```
+
+Returns **[Object][1]**&#x20;
+
+## concurrency
+
+Gets or, when a concurrency is provided, sets
+the maximum number of threads *libvips* should use to process *each image*.
+These are from a thread pool managed by glib,
+which helps avoid the overhead of creating new threads.
+
+This method always returns the current concurrency.
+
+The default value is the number of CPU cores,
+except when using glibc-based Linux without jemalloc,
+where the default is `1` to help reduce memory fragmentation.
+
+A value of `0` will reset this to the number of CPU cores.
+
+Some image format libraries spawn additional threads,
+e.g. libaom manages its own 4 threads when encoding AVIF images,
+and these are independent of the value set here.
+
+The maximum number of images that sharp can process in parallel
+is controlled by libuv's `UV_THREADPOOL_SIZE` environment variable,
+which defaults to 4.
+
+[https://nodejs.org/api/cli.html#uv\_threadpool\_sizesize][12]
+
+For example, by default, a machine with 8 CPU cores will process
+4 images in parallel and use up to 8 threads per image,
+so there will be up to 32 concurrent threads.
+
+### Parameters
+
+*   `concurrency` **[number][11]?**&#x20;
+
+### Examples
+
+```javascript
+const threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
+Returns **[number][11]** concurrency
+
+## queue
+
+An EventEmitter that emits a `change` event when a task is either:
+
+*   queued, waiting for *libuv* to provide a worker thread
+*   complete
+
+### Examples
+
+```javascript
+sharp.queue.on('change', function(queueLength) {
+  console.log('Queue contains ' + queueLength + ' task(s)');
+});
+```
+
+## counters
+
+Provides access to internal task counters.
+
+*   queue is the number of tasks this module has queued waiting for *libuv* to provide a worker thread from its pool.
+*   process is the number of resize tasks currently being processed.
+
+### Examples
+
+```javascript
+const counters = sharp.counters(); // { queue: 2, process: 4 }
+```
+
+Returns **[Object][1]**&#x20;
+
+## simd
+
+Get and set use of SIMD vector unit instructions.
+Requires libvips to have been compiled with liborc support.
+
+Improves the performance of `resize`, `blur` and `sharpen` operations
+by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
+
+### Parameters
+
+*   `simd` **[boolean][10]**  (optional, default `true`)
+
+### Examples
+
+```javascript
+const simd = sharp.simd();
+// simd is `true` if the runtime use of liborc is currently enabled
+```
+
+```javascript
+const simd = sharp.simd(false);
+// prevent libvips from using liborc at runtime
+```
+
+Returns **[boolean][10]**&#x20;
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[3]: http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
+
+[4]: http://en.wikipedia.org/wiki/Bilinear_interpolation
+
+[5]: http://en.wikipedia.org/wiki/Bicubic_interpolation
+
+[6]: https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100
+
+[7]: http://en.wikipedia.org/wiki/Acutance
+
+[8]: http://eprints.soton.ac.uk/268086/
+
+[9]: https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48
+
+[10]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[11]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[12]: https://nodejs.org/api/cli.html#uv_threadpool_sizesize

docs/api.md

@@ -1,659 +0,0 @@
-# API
-
-```javascript
-var sharp = require('sharp');
-```
-
-### Input
-
-#### sharp([input])
-
-Constructor to which further methods are chained. `input`, if present, can be one of:
-
-* Buffer containing JPEG, PNG, WebP, GIF* or TIFF image data, or
-* String containing the path to an image file, with most major formats supported.
-
-The object returned implements the
-[stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
-
-JPEG, PNG, WebP, GIF* or TIFF format image data
-can be streamed into the object when `input` is not provided.
-
-JPEG, PNG or WebP format image data can be streamed out from this object.
-
-\* libvips 8.0.0+ is required for Buffer/Stream input of GIF and other `magick` formats.
-
-```javascript
-sharp('input.jpg')
-  .resize(300, 200)
-  .toFile('output.jpg', function(err) {
-    // output.jpg is a 300 pixels wide and 200 pixels high image
-    // containing a scaled and cropped version of input.jpg
-  });
-```
-
-#### metadata([callback])
-
-Fast access to image metadata without decoding any compressed image data.
-
-`callback`, if present, gets the arguments `(err, metadata)` where `metadata` has the attributes:
-
-* `format`: Name of decoder to be used to decompress image data e.g. `jpeg`, `png`, `webp` (for file-based input additionally `tiff`, `magick` and `openslide`)
-* `width`: Number of pixels wide
-* `height`: Number of pixels high
-* `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L522)
-* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
-* `hasProfile`: Boolean indicating the presence of an embedded ICC profile
-* `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
-* `orientation`: Number value of the EXIF Orientation header, if present
-* `exif`: Buffer containing raw EXIF data, if present
-* `icc`: Buffer containing raw [ICC](https://www.npmjs.com/package/icc) profile data, if present
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-```javascript
-var image = sharp(inputJpg);
-image
-  .metadata()
-  .then(function(metadata) {
-    return image
-      .resize(Math.round(metadata.width / 2))
-      .webp()
-      .toBuffer();
-  })
-  .then(function(data) {
-    // data contains a WebP image half the width and height of the original JPEG
-  });
-```
-
-#### clone()
-
-Takes a "snapshot" of the instance, returning a new instance.
-Cloned instances inherit the input of their parent instance.
-
-This allows multiple output Streams
-and therefore multiple processing pipelines
-to share a single input Stream.
-
-```javascript
-var pipeline = sharp().rotate();
-pipeline.clone().resize(800, 600).pipe(firstWritableStream);
-pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
-readableStream.pipe(pipeline);
-// firstWritableStream receives auto-rotated, resized readableStream
-// secondWritableStream receives auto-rotated, extracted region of readableStream
-```
-
-#### sequentialRead()
-
-An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`.
-This will reduce memory usage and can improve performance on some systems.
-
-#### limitInputPixels(pixels)
-
-Do not process input images where the number of pixels (width * height) exceeds this limit.
-
-`pixels` is the integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF).
-
-### Resizing
-
-#### resize([width], [height])
-
-Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
-
-`width` is the integral Number of pixels wide the resultant image should be, between 1 and 16383 (0x3FFF). Use `null` or `undefined` to auto-scale the width to match the height.
-
-`height` is the integral Number of pixels high the resultant image should be, between 1 and 16383. Use `null` or `undefined` to auto-scale the height to match the width.
-
-#### crop([gravity])
-
-Crop the resized image to the exact size specified, the default behaviour.
-
-`gravity`, if present, is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
-
-Possible values are `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` and `centre`.
-The default gravity is `center`/`centre`.
-
-```javascript
-var transformer = sharp()
-  .resize(300, 200)
-  .crop(sharp.gravity.north)
-  .on('error', function(err) {
-    console.log(err);
-  });
-// Read image data from readableStream, resize and write image data to writableStream
-readableStream.pipe(transformer).pipe(writableStream);
-```
-
-#### embed()
-
-Preserving aspect ratio, resize the image to the
-maximum `width` or `height` specified
-then embed on a background of the exact
-`width` and `height` specified.
-
-If the background contains an alpha value
-then WebP and PNG format output images will
-contain an alpha channel,
-even when the input image does not.
-
-```javascript
-sharp('input.gif')
-  .resize(200, 300)
-  .background({r: 0, g: 0, b: 0, a: 0})
-  .embed()
-  .toFormat(sharp.format.webp)
-  .toBuffer(function(err, outputBuffer) {
-    if (err) {
-      throw err;
-    }
-    // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
-    // containing a scaled version, embedded on a transparent canvas, of input.gif
-  });
-```
-
-#### max()
-
-Preserving aspect ratio,
-resize the image to be as large as possible
-while ensuring its dimensions are less than or equal to
-the `width` and `height` specified.
-
-Both `width` and `height` must be provided via
-`resize` otherwise the behaviour will default to `crop`.
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 200)
-  .max()
-  .toFormat('jpeg')
-  .toBuffer()
-  .then(function(outputBuffer) {
-    // outputBuffer contains JPEG image data no wider than 200 pixels and no higher
-    // than 200 pixels regardless of the inputBuffer image dimensions
-  });
-```
-
-#### min()
-
-Preserving aspect ratio,
-resize the image to be as small as possible
-while ensuring its dimensions are greater than or equal to
-the `width` and `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
-
-#### withoutEnlargement()
-
-Do not enlarge the output image
-if the input image width *or* height
-are already less than the required dimensions.
-
-This is equivalent to GraphicsMagick's `>` geometry option:
-"*change the dimensions of the image only
-if its width or height exceeds the geometry specification*".
-
-#### ignoreAspectRatio()
-
-Ignoring the aspect ratio of the input, stretch the image to the exact `width` and/or `height` provided via `resize`.
-
-#### interpolateWith(interpolator)
-
-Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
-
-The default interpolator is `bicubic`, providing a general-purpose interpolator that is both fast and of good quality.
-
-Possible interpolators, in order of performance, are:
-
-* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation), suitable for image enlargement only.
-* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), faster than bicubic but with less smooth results.
-* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
-* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
-* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2.
-* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
-
-[Compare the output of these interpolators](https://github.com/lovell/sharp/tree/master/test/interpolators)
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 300)
-  .interpolateWith(sharp.interpolator.nohalo)
-  .background('white')
-  .embed()
-  .toFile('output.tiff')
-  .then(function() {
-    // output.tiff is a 200 pixels wide and 300 pixels high image
-    // containing a nohalo scaled version, embedded on a white canvas,
-    // of the image data in inputBuffer
-  });
-```
-
-### Operations
-
-#### extract({ left: left, top: top, width: width, height: height })
-
-Extract a region of the image. Can be used with or without a `resize` operation.
-
-`left` and `top` are the offset, in pixels, from the top-left corner.
-
-`width` and `height` are the dimensions of the extracted image.
-
-Use `extract` before `resize` for pre-resize extraction. Use `extract` after `resize` for post-resize extraction. Use `extract` before and after for both.
-
-```javascript
-sharp(input)
-  .extract({ left: left, top: top, width: width, height: height })
-  .toFile(output, function(err) {
-    // Extract a region of the input image, saving in the same format.
-  });
-```
-
-```javascript
-sharp(input)
-  .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
-  .resize(width, height)
-  .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
-  .toFile(output, function(err) {
-    // Extract a region, resize, then extract from the resized image
-  });
-```
-
-#### background(rgba)
-
-Set the background for the `embed` and `flatten` operations.
-
-`rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
-
-The alpha value is a float between `0` (transparent) and `1` (opaque).
-
-The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency.
-
-#### flatten()
-
-Merge alpha transparency channel, if any, with `background`.
-
-#### negate()
-
-Produces the "negative" of the image.  White => Black, Black => White, Blue => Yellow, etc.
-
-#### rotate([angle])
-
-Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
-
-`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
-
-Use this method without `angle` to determine the angle from EXIF data. Mirroring is supported and may infer the use of a `flip` operation.
-
-Method order is important when both rotating and extracting regions, for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
-
-The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
-
-```javascript
-var pipeline = sharp()
-  .rotate()
-  .resize(null, 200)
-  .progressive()
-  .toBuffer(function(err, outputBuffer, info) {
-    if (err) {
-      throw err;
-    }
-    // outputBuffer contains 200px high progressive JPEG image data,
-    // auto-rotated using EXIF Orientation tag
-    // info.width and info.height contain the dimensions of the resized image
-  });
-readableStream.pipe(pipeline);
-```
-
-#### flip()
-
-Flip the image about the vertical Y axis. This always occurs after rotation, if any.
-The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
-
-#### flop()
-
-Flop the image about the horizontal X axis. This always occurs after rotation, if any.
-The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
-
-#### blur([sigma])
-
-When used without parameters, performs a fast, mild blur of the output image. This typically reduces performance by 10%.
-
-When a `sigma` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 25%.
-
-* `sigma`, if present, is a Number between 0.3 and 1000 representing the approximate blur radius in pixels.
-
-#### sharpen([radius], [flat], [jagged])
-
-When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
-
-When a `radius` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space. Separate control over the level of sharpening in "flat" and "jagged" areas is available. This typically reduces performance by 50%.
-
-* `radius`, if present, is an integral Number representing the sharpen mask radius in pixels.
-* `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
-* `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
-
-#### threshold([threshold])
-
-Converts all pixels in the image to greyscale white or black.  Any pixel greather-than-or-equal-to the threshold (0..255) will be white.  All others will be black.
-
-* `threshold`, if present, is a Number, representing the level above which pixels will be forced to white.
-
-#### gamma([gamma])
-
-Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma` then increasing the encoding (brighten) post-resize at a factor of `gamma`.
-
-`gamma`, if present, is a Number between 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.
-
-This can improve the perceived brightness of a resized image in non-linear colour spaces.
-
-JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
-
-#### grayscale() / greyscale()
-
-Convert to 8-bit greyscale; 256 shades of grey.
-
-This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
-
-The output image will still be web-friendly sRGB and contain three (identical) channels.
-
-#### normalize() / normalise()
-
-Enhance output image contrast by stretching its luminance to cover the full dynamic range. This typically reduces performance by 30%.
-
-#### overlayWith(path)
-
-_Experimental_
-
-Alpha composite image at `path` over the processed (resized, extracted) image. The dimensions of the two images must match.
-
-* `path` is a String containing the path to an image file with an alpha channel.
-
-```javascript
-sharp('input.png')
-  .rotate(180)
-  .resize(300)
-  .flatten()
-  .background('#ff6600')
-  .overlayWith('overlay.png')
-  .sharpen()
-  .withMetadata()
-  .quality(90)
-  .webp()
-  .toBuffer()
-  .then(function(outputBuffer) {
-    // outputBuffer contains upside down, 300px wide, alpha channel flattened
-    // onto orange background, composited with overlay.png, sharpened,
-    // with metadata, 90% quality WebP image data. Phew!
-  });
-```
-
-### Output
-
-#### toFile(path, [callback])
-
-`path` is a String containing the path to write the image data to. The format is inferred from the extension, with JPEG, PNG, WebP, TIFF and DZI supported.
-
-`callback`, if present, is called with two arguments `(err, info)` where:
-
-* `err` contains an error message, if any.
-* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-#### toBuffer([callback])
-
-Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
-
-`callback`, if present, gets three arguments `(err, buffer, info)` where:
-
-* `err` is an error message, if any.
-* `buffer` is the output image data.
-* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-#### jpeg()
-
-Use JPEG format for the output image.
-
-#### png()
-
-Use PNG format for the output image.
-
-#### webp()
-
-Use WebP format for the output image.
-
-#### raw()
-
-Provide raw, uncompressed uint8 (unsigned char) image data for Buffer and Stream based output.
-
-The number of channels depends on the input image and selected options.
-
-* 1 channel for images converted to `greyscale()`, with each byte representing one pixel.
-* 3 channels for colour images without alpha transparency, with bytes ordered \[red, green, blue, red, green, blue, etc.\]).
-* 4 channels for colour images with alpha transparency, with bytes ordered \[red, green, blue, alpha, red, green, blue, alpha, etc.\].
-
-#### toFormat(format)
-
-Convenience method for the above output format methods, where `format` is either:
-
-* an attribute of the `sharp.format` Object e.g. `sharp.format.jpeg`, or
-* a String containing `jpeg`, `png`, `webp` or `raw`.
-
-#### quality(quality)
-
-The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
-
-`quality` is a Number between 1 and 100.
-
-#### progressive()
-
-Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
-
-#### withMetadata([metadata])
-
-Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
-This will also convert to and add the latest web-friendly v2 sRGB ICC profile.
-
-The optional `metadata` parameter, if present, is an Object with the attributes to update.
-New attributes cannot be inserted, only existing attributes updated.
-
-* `orientation` is an integral Number between 0 and 7, used to update the value of the EXIF `Orientation` tag.
-This has no effect if the input image does not have an EXIF `Orientation` tag.
-
-The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
-
-#### tile([size], [overlap])
-
-The size and overlap, in pixels, of square Deep Zoom image pyramid tiles.
-
-* `size` is an integral Number between 1 and 8192. The default value is 256 pixels.
-* `overlap` is an integral Number between 0 and 8192. The default value is 0 pixels.
-
-```javascript
-sharp('input.tiff').tile(256).toFile('output.dzi', function(err, info) {
-  // The output.dzi file is the XML format Deep Zoom definition
-  // The output_files directory contains 256x256 pixel tiles grouped by zoom level
-});
-```
-
-#### withoutChromaSubsampling()
-
-Disable the use of [chroma subsampling](http://en.wikipedia.org/wiki/Chroma_subsampling) with JPEG output (4:4:4).
-
-This can improve colour representation at higher quality settings (90+),
-but usually increases output file size and typically reduces performance by 25%.
-
-The default behaviour is to use chroma subsampling (4:2:0).
-
-#### compressionLevel(compressionLevel)
-
-An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
-
-`compressionLevel` is a Number between 0 and 9.
-
-#### withoutAdaptiveFiltering()
-
-An advanced setting to disable adaptive row filtering for the lossless PNG output format.
-
-#### trellisQuantisation() / trellisQuantization()
-
-_Requires libvips to have been compiled with mozjpeg support_
-
-An advanced setting to apply the use of
-[trellis quantisation](http://en.wikipedia.org/wiki/Trellis_quantization) with JPEG output.
-Reduces file size and slightly increases relative quality at the cost of increased compression time.
-
-#### overshootDeringing()
-
-_Requires libvips to have been compiled with mozjpeg support_
-
-An advanced setting to reduce the effects of
-[ringing](http://en.wikipedia.org/wiki/Ringing_%28signal%29) in JPEG output,
-in particular where black text appears on a white background (or vice versa).
-
-#### optimiseScans() / optimizeScans()
-
-_Requires libvips to have been compiled with mozjpeg support_
-
-An advanced setting for progressive (interlace) JPEG output.
-Calculates which spectrum of DCT coefficients uses the fewest bits.
-Usually reduces file size at the cost of increased compression time.
-
-### Attributes
-
-#### format
-
-An Object containing nested boolean values
-representing the available input and output formats/methods,
-for example:
-
-```javascript
-> console.dir(sharp.format);
-
-{ jpeg: { id: 'jpeg',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  png: { id: 'png',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  webp: { id: 'webp',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  tiff: { id: 'tiff',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: false, stream: false } },
-  magick: { id: 'magick',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: false, buffer: false, stream: false } },
-  raw: { id: 'raw',
-    input: { file: false, buffer: false, stream: false },
-    output: { file: false, buffer: true, stream: true } } }
-```
-
-#### queue
-
-An EventEmitter that emits a `change` event when a task is either:
-
-* queued, waiting for _libuv_ to provide a worker thread
-* complete
-
-```javascript
-sharp.queue.on('change', function(queueLength) {
-  console.log('Queue contains ' + queueLength + ' task(s)');
-});
-```
-
-#### versions
-
-An Object containing the version numbers of libvips and, on Linux, its dependencies.
-
-```javascript
-> console.log(sharp.versions);
-
-{ zlib: '1.2.8',
-  ffi: '3.2.1',
-  glib: '2.46.2',
-  xml: '2.9.2',
-  gsf: '1.14.34',
-  exif: '0.6.21',
-  jpeg: '1.4.2',
-  png: '1.6.19',
-  lcms: '2.7',
-  webp: '0.4.4',
-  tiff: '4.0.6',
-  magick: '6.9.2-6',
-  orc: '0.4.24',
-  vips: '8.1.1' }
-```
-
-### Utilities
-
-#### sharp.cache([memory], [items])
-
-If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.
-
-* `memory` is the maximum memory in MB to use for this cache, with a default value of 100
-* `items` is the maximum number of operations to cache, with a default value of 500
-
-This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
-
-```javascript
-var stats = sharp.cache(); // { current: 75, high: 99, memory: 100, items: 500 }
-sharp.cache(200); // { current: 75, high: 99, memory: 200, items: 500 }
-sharp.cache(50, 200); // { current: 49, high: 99, memory: 50, items: 200}
-```
-
-#### sharp.concurrency([threads])
-
-`threads`, if provided, is the Number of threads _libvips'_ should create for processing each image. The default value is the number of CPU cores. A value of `0` will reset to this default.
-
-This method always returns the current concurrency.
-
-```javascript
-var threads = sharp.concurrency(); // 4
-sharp.concurrency(2); // 2
-sharp.concurrency(0); // 4
-```
-
-The maximum number of images that can be processed in parallel is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
-
-#### sharp.counters()
-
-Provides access to internal task counters.
-
-* `queue` is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
-* `process` is the number of resize tasks currently being processed.
-
-```javascript
-var counters = sharp.counters(); // { queue: 2, process: 4 }
-```
-
-#### sharp.simd([enable])
-
-_Requires libvips to have been compiled with liborc support_
-
-Improves the performance of `resize`, `blur` and `sharpen` operations
-by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
-
-* `enable`, if present, is a boolean where `true` enables and `false` disables the use of SIMD.
-
-This method always returns the current state.
-
-This feature is currently disabled by default
-but future versions may enable it by default.
-
-When enabled, versions of liborc prior to 0.4.24
-and versions of libvips prior to 8.2.0
-have been known to crash under heavy load.
-
-```javascript
-var simd = sharp.simd();
-// simd is `true` if SIMD is currently enabled
-```
-
-```javascript
-var simd = sharp.simd(true);
-// attempts to enable the use of SIMD, returning true if available
-```

docs/build.js

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

docs/firebase.json

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

docs/humans.txt

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

docs/image/sharp-logo-mono.svg

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

docs/image/sharp-logo.svg

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

docs/index.md

@@ -1,108 +0,0 @@
-# sharp
-
-The typical use case for this high speed Node.js module
-is to convert large images of many formats to
-smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
-
-Resizing an image is typically 4x faster than using
-the quickest ImageMagick and GraphicsMagick settings.
-
-Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
-
-As well as image resizing, operations such as
-rotation, extraction, compositing and gamma correction are available.
-
-64-bit Windows and recent Linux systems do not require
-the installation of any external runtime dependencies.
-
-Use with OS X is as simple as running `brew install homebrew/science/vips`
-to install the libvips dependency.
-
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
-
-### Formats
-
-This module supports reading JPEG, PNG, WebP, TIFF, OpenSlide,
-GIF and other libmagick-supported formats.
-
-Output images can be in JPEG, PNG and WebP formats as well as uncompressed raw pixel data.
-
-Streams, Buffer objects and the filesystem can be used for input and output.
-
-A single input Stream can be split into multiple processing pipelines and output Streams.
-
-Deep Zoom image pyramids can be generated,
-suitable for use with "slippy map" tile viewers like
-[OpenSeadragon](https://github.com/openseadragon/openseadragon)
-and [Leaflet](https://github.com/turban/Leaflet.Zoomify).
-
-### Fast
-
-This module is powered by the blazingly fast
-[libvips](https://github.com/jcupitt/libvips) image processing library,
-originally created in 1989 at Birkbeck College
-and currently maintained by
-[John Cupitt](https://github.com/jcupitt).
-
-Only small regions of uncompressed image data
-are held in memory and processed at a time,
-taking full advantage of multiple CPU cores and L1/L2/L3 cache.
-
-Everything remains non-blocking thanks to _libuv_,
-no child processes are spawned and Promises/A+ are supported.
-
-### Optimal
-
-Huffman tables are optimised when generating JPEG output images
-without having to use separate command line tools like
-[jpegoptim](https://github.com/tjko/jpegoptim) and
-[jpegtran](http://jpegclub.org/jpegtran/).
-
-PNG filtering can be disabled,
-which for diagrams and line art often produces the same result
-as [pngcrush](http://pmt.sourceforge.net/pngcrush/).
-
-### Contributing
-
-A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
-covers reporting bugs, requesting features and submitting code changes.
-
-### Credits
-
-This module would never have been possible without
-the help and code contributions of the following people:
-
-* [John Cupitt](https://github.com/jcupitt)
-* [Pierre Inglebert](https://github.com/pierreinglebert)
-* [Jonathan Ong](https://github.com/jonathanong)
-* [Chanon Sajjamanochai](https://github.com/chanon)
-* [Juliano Julio](https://github.com/julianojulio)
-* [Daniel Gasienica](https://github.com/gasi)
-* [Julian Walker](https://github.com/julianwa)
-* [Amit Pitaru](https://github.com/apitaru)
-* [Brandon Aaron](https://github.com/brandonaaron)
-* [Andreas Lind](https://github.com/papandreou)
-* [Maurus Cuelenaere](https://github.com/mcuelenaere)
-* [Linus Unnebäck](https://github.com/LinusU)
-* [Victor Mateevitsi](https://github.com/mvictoras)
-* [Alaric Holloway](https://github.com/skedastik)
-* [Bernhard K. Weisshuhn](https://github.com/bkw)
-* [David A. Carley](https://github.com/dacarley)
-
-Thank you!
-
-### Licence
-
-Copyright 2013, 2014, 2015 Lovell Fuller and contributors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

docs/install.md

@@ -4,113 +4,350 @@
 npm install sharp
 ```
 
-### Prerequisites
-
-* C++11 compatible compiler such as gcc 4.6+ (Node v4+ requires gcc 4.8+), clang 3.0+ or MSVC 2013
-* [node-gyp](https://github.com/TooTallNate/node-gyp#installation)
-
-### Linux
-
-[![Ubuntu 14.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
-[![Linux Build Status](https://circleci.com/gh/lovell/sharp.svg?style=svg&circle-token=6cb6d1d287a51af83722b19ed8885377fbc85e5c)](https://circleci.com/gh/lovell/sharp)
-
-libvips and its dependencies are fetched and stored within `node_modules/sharp` during `npm install`.
-This involves an automated HTTPS download of approximately 6MB.
-
-Most recent Linux-based operating systems running on x64 and ARMv6+ CPUs should "just work", e.g.:
-
-* Debian 7, 8
-* Ubuntu 12.04, 14.04, 14.10, 15.04, 15.10
-* Centos 7
-* Fedora 21, 22, 23
-* openSUSE 13.2
-* Archlinux 2015.06.01
-* Raspbian Jessie
-
-Preference will be given to an existing globally-installed (via `pkg-config`)
-version of libvips that meets the minimum version requirement.
-This allows the use of newer versions of libvips with older versions of sharp.
-
-For older Linux-based operating systems and 32-bit Intel CPUs,
-a system-wide installation of the most suitable version of
-libvips and its dependencies can be achieved by running
-the following command as a user with `sudo` access
-(requires `curl` and `pkg-config`):
-
 ```sh
-curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
+yarn add sharp
 ```
 
-### Mac OS
+## Prerequisites
 
-[![OS X 10.9.5 Build Status](https://travis-ci.org/lovell/sharp-osx-ci.png?branch=master)](https://travis-ci.org/lovell/sharp-osx-ci)
+* Node.js >= 14.15.0
 
-libvips must be installed before `npm install` is run.
-This can be achieved via homebrew:
+## Prebuilt binaries
+
+Ready-compiled sharp and libvips binaries are provided for use on the most common platforms:
+
+* macOS x64 (>= 10.13)
+* 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
+
+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 and SVG (input) image formats.
+
+The following platforms have prebuilt libvips but not sharp:
+
+* 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 ARMv7 (glibc <= 2.27, musl)
+* Linux ARMv6 (glibc <= 2.27, musl)
+* Linux PowerPC
+* FreeBSD
+* OpenBSD
+
+## Common problems
+
+The architecture and platform of Node.js used for `npm install`
+must be the same as the architecture and platform of Node.js used at runtime.
+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 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.
+
+Check the output of running `npm install --verbose --foreground-scripts sharp` for useful error messages.
+
+## Apple M1
+
+Prebuilt sharp and libvips binaries have been provided for macOS on ARM64 since sharp v0.29.0.
+
+## Cross-platform
+
+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
-brew install homebrew/science/vips
+npm install --platform=... --arch=... --arm-version=... sharp
 ```
 
-For GIF input and WebP output suppport use:
+* `--platform`: one of `linux`, `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`).
+* `--libc`: one of `glibc` or `musl`. This option only works with platform `linux`, defaults to `glibc`
+* `--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`, `npm_config_libc`
+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
-brew install homebrew/science/vips --with-imagemagick --with-webp
+npm install --arch=arm64 --platform=linux --libc=musl sharp
 ```
 
-A missing or incorrectly configured _Xcode Command Line Tools_ installation
-[can lead](https://github.com/lovell/sharp/issues/80) to a
-`library not found for -ljpeg` error.
-If so, please try: `xcode-select --install`.
+If the current machine is Alpine Linux and the target machine is Debian Linux on x64 cpu,
+use the following flags:
 
-The _gettext_ dependency of _libvips_
-[can lead](https://github.com/lovell/sharp/issues/9)
-to a `library not found for -lintl` error.
-If so, please try `brew link gettext --force`.
+```sh
+npm install --arch=x64 --platform=linux --libc=glibc sharp
+```
 
-### Windows
+Multiple platforms and architectures can be supported within the same installation tree.
+The following example for macOS installs x64 binaries then adds (via a rebuild) arm64 binaries:
 
-[![Windows x64 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
+```sh
+npm install --platform=darwin --arch=x64 sharp
+npm rebuild --platform=darwin --arch=arm64 sharp
+```
 
-libvips and its dependencies are fetched and stored within `node_modules\sharp` during `npm install`.
-This involves an automated HTTPS download of approximately 9MB.
+## Custom libvips
 
-Only 64-bit (x64) `node.exe` is supported.
-The WebP format is currently unavailable on Windows.
+To use a custom, globally-installed version of libvips instead of the provided binaries,
+make sure it is at least the version listed under `config.libvips` in the `package.json` file
+and that it can be located using `pkg-config --modversion vips-cpp`.
 
-### FreeBSD
+For help compiling libvips and its dependencies, please see
+[building libvips from source](https://www.libvips.org/install.html#building-libvips-from-source).
 
-libvips must be installed before `npm install` is run.
-This can be achieved via [FreshPorts](https://www.freshports.org/graphics/vips/):
+The use of a globally-installed libvips is unsupported on Windows.
+
+## Building from source
+
+This module will be compiled from source at `npm install` time when:
+
+* a globally-installed libvips is detected (set the `SHARP_IGNORE_GLOBAL_LIBVIPS` environment variable to skip this),
+* prebuilt sharp binaries do not exist for the current platform, or
+* when the `npm install --build-from-source` flag is used.
+
+Building from source requires:
+
+* C++11 compiler
+* [node-gyp](https://github.com/nodejs/node-gyp#installation) and its dependencies
+
+## Custom prebuilt binaries
+
+This is an advanced approach that most people will not require.
+
+### Prebuilt sharp binaries
+
+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.
+
+URL example:
+if `sharp_binary_host` is set to `https://hostname/path`
+and the sharp version is `1.2.3` then the resultant URL will be
+`https://hostname/path/sharp-v1.2.3-napi-v5-platform-arch.tar.gz`.
+
+Filename example:
+if `sharp_local_prebuilds` is set to `/path`
+and the sharp version is `1.2.3` then the resultant filename will be
+`/path/sharp-v1.2.3-napi-v5-platform-arch.tar.gz`.
+
+### Prebuilt libvips binaries
+
+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.
+
+To install the prebuilt libvips binaries from a directory on the local filesystem,
+set the `sharp_libvips_local_prebuilds` npm config option
+or the `npm_config_sharp_libvips_local_prebuilds` environment variable.
+
+The version subpath and filename are appended to these.
+
+URL example:
+if `sharp_libvips_binary_host` is set to `https://hostname/path`
+and the libvips version is `4.5.6` then the resultant URL will be
+`https://hostname/path/v4.5.6/libvips-4.5.6-platform-arch.tar.br`.
+
+Filename example:
+if `sharp_libvips_local_prebuilds` is set to `/path`
+and the libvips version is `4.5.6` then the resultant filename will be
+`/path/v4.5.6/libvips-4.5.6-platform-arch.tar.br`.
+
+See the Chinese mirror below for a further example.
+
+## Chinese mirror
+
+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://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://npmmirror.com/mirrors/sharp" \
+  npm_config_sharp_libvips_binary_host="https://npmmirror.com/mirrors/sharp-libvips" \
+  npm install sharp
+```
+
+## FreeBSD
+
+The `vips` package must be installed before `npm install` is run.
+
+```sh
+pkg install -y pkgconf vips
+```
 
 ```sh
 cd /usr/ports/graphics/vips/ && make install clean
 ```
 
-### Heroku
+## Linux memory allocator
 
-[Alessandro Tagliapietra](https://github.com/alex88) maintains an
-[Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips)
-and its dependencies.
+The default memory allocator on most glibc-based Linux systems
+(e.g. Debian, Red Hat) is unsuitable for long-running, multi-threaded
+processes that involve lots of small memory allocations.
 
-### Docker
+For this reason, by default, sharp will limit the use of thread-based
+[concurrency](api-utility#concurrency) when the glibc allocator is
+detected at runtime.
 
-[Marc Bachmann](https://github.com/marcbachmann) maintains an
-[Ubuntu-based Dockerfile for libvips](https://github.com/marcbachmann/dockerfile-libvips).
+To help avoid fragmentation and improve performance on these systems,
+the use of an alternative memory allocator such as
+[jemalloc](https://github.com/jemalloc/jemalloc) is recommended.
+
+Those using musl-based Linux (e.g. Alpine) and non-Linux systems are
+unaffected.
+
+## Heroku
+
+Add the
+[jemalloc buildpack](https://github.com/gaffneyc/heroku-buildpack-jemalloc)
+to reduce the effects of memory fragmentation.
+
+Set
+[NODE_MODULES_CACHE](https://devcenter.heroku.com/articles/nodejs-support#cache-behavior)
+to `false` when using the `yarn` package manager.
+
+## AWS Lambda
+
+The `node_modules` directory of the
+[deployment package](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-package.html)
+must include binaries for the Linux x64 platform.
+
+When building your deployment package on machines other than Linux x64 (glibc),
+run the following additional command after `npm install`:
 
 ```sh
-docker pull marcbachmann/libvips
+npm install
+rm -rf node_modules/sharp
+SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install --arch=x64 --platform=linux --libc=glibc sharp
 ```
 
-[Will Jordan](https://github.com/wjordan) maintains an
-[Alpine-based Dockerfile for libvips](https://github.com/wjordan/dockerfile-libvips).
+To get the best performance select the largest memory available.
+A 1536 MB function provides ~12x more CPU time than a 128 MB function.
+
+## Bundlers
+
+### webpack
+
+Ensure sharp is excluded from bundling via the
+[externals](https://webpack.js.org/configuration/externals/)
+configuration.
+
+```js
+externals: {
+  'sharp': 'commonjs sharp'
+}
+```
+
+### esbuild
+
+Ensure sharp is excluded from bundling via the
+[external](https://esbuild.github.io/api/#external)
+configuration.
+
+```js
+buildSync({
+  entryPoints: ['app.js'],
+  bundle: true,
+  platform: 'node',
+  external: ['sharp'],
+})
+```
 
 ```sh
-docker pull wjordan/libvips
+esbuild app.js --bundle --platform=node --external:sharp
 ```
 
-### Build tools
+For `serverless-esbuild`, ensure platform-specific binaries are installed
+via the `serverless.yml` configuration.
 
-* [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
-* [gulp-sharp](https://www.npmjs.com/package/gulp-sharp)
-* [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
+```yaml
+custom:
+  esbuild:
+    external:
+      - sharp
+    packagerOptions:
+      scripts:
+        - npm install --arch=x64 --platform=linux sharp
+```
+
+## Fonts
+
+When creating text images or rendering SVG images that contain text elements,
+`fontconfig` is used to find the relevant fonts.
+
+On Windows and macOS systems, all system fonts are available for use.
+
+On macOS systems using Homebrew, you may need to set the
+`PANGOCAIRO_BACKEND` environment variable to a value of `fontconfig`
+to ensure it is used for font discovery instead of Core Text.
+
+On Linux systems, fonts that include the relevant
+[`fontconfig` configuration](https://www.freedesktop.org/software/fontconfig/fontconfig-user.html)
+when installed via package manager are available for use.
+
+If `fontconfig` configuration is not found, the following error will occur:
+```
+Fontconfig error: Cannot load default config file
+```
+
+In serverless environments where there is no control over font packages,
+use the `FONTCONFIG_PATH` environment variable to point to a custom location.
+
+Embedded SVG fonts are unsupported.
+
+## Worker threads
+
+On some platforms, including glibc-based Linux,
+the main thread must call `require('sharp')`
+_before_ worker threads are created.
+This is to ensure shared libraries remain loaded in memory
+until after all threads are complete.
+
+Without this, the following error may occur:
+```
+Module did not self-register
+```
+
+## Known conflicts
+
+### Canvas and Windows
+
+The prebuilt binaries provided by `canvas` for Windows depend on the unmaintained GTK 2, last updated in 2011.
+
+These conflict with the modern, up-to-date binaries provided by sharp.
+
+If both modules are used in the same Windows process, the following error will occur:
+```
+The specified procedure could not be found.
+```

docs/performance.md

@@ -1,70 +1,55 @@
 # Performance
 
-### Test environment
+A test to benchmark the performance of this module relative to alternatives.
 
-* AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4) (4x E5-2666 v3 @2.90GHz)
-* Amazon Linux 2015.09.1
-* Node.js v5.1.0
+## The contenders
 
-### The contenders
-
-* [jimp](https://www.npmjs.com/package/jimp) v0.2.19 - Image processing in pure JavaScript. Bilinear interpolation only.
-* [lwip](https://www.npmjs.com/package/lwip) v0.0.8 - Wrapper around CImg, compiles dependencies from source.
-* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) @5ab570e - Wrapper around libmagick++, supports Buffers only.
+* [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.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.21.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.12.0 / libvips v8.1.1 - Caching within libvips disabled to ensure a fair comparison.
+* [gm](https://www.npmjs.com/package/gm) v1.23.1 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
+* [@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.31.0 / libvips v8.13.1 - Caching within libvips disabled to ensure a fair comparison.
 
-### The task
+## The task
 
-Decompress a 2725x2225 JPEG image, resize to 720x480 using bicubic interpolation (where available), then compress to JPEG.
+Decompress a 2725x2225 JPEG image,
+resize to 720x588 using Lanczos 3 resampling (where available),
+then compress to JPEG at a "quality" setting of 80.
 
-### Results
+## Test environment
+
+* AWS EC2 eu-west-1 [c6a.xlarge](https://aws.amazon.com/ec2/instance-types/c6a/) (4x AMD EPYC 7R13)
+* Ubuntu 22.04 (ami-051f7c00cb18501ee)
+* Node.js 16.17.0
+
+## Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp               | file   | file   |    0.99 |      1.0 |
-| jimp               | buffer | buffer |    1.05 |      1.1 |
-| lwip               | file   | file   |    1.13 |      1.1 |
-| lwip               | buffer | buffer |    1.13 |      1.1 |
-| imagemagick-native | buffer | buffer |    1.67 |      1.7 |
-| imagemagick        | file   | file   |    5.19 |      5.2 |
-| gm                 | buffer | buffer |    5.56 |      5.6 |
-| gm                 | file   | file   |    5.59 |      5.6 |
-| sharp              | stream | stream |   21.91 |     22.1 |
-| sharp              | file   | file   |   22.79 |     23.0 |
-| sharp              | file   | buffer |   22.91 |     23.1 |
-| sharp              | buffer | file   |   23.03 |     23.3 |
-| sharp              | buffer | buffer |   23.15 |     23.4 |
+| jimp               | buffer | buffer |    0.96 |      1.0 |
+| squoosh-cli        | file   | file   |    1.10 |      1.1 |
+| squoosh-lib        | buffer | buffer |    1.87 |      1.9 |
+| mapnik             | buffer | buffer |    3.48 |      3.6 |
+| gm                 | buffer | buffer |    8.53 |      8.9 |
+| gm                 | file   | file   |    8.60 |      9.0 |
+| imagemagick        | file   | file   |    9.30 |      9.7 |
+| sharp              | stream | stream |   32.86 |     34.2 |
+| sharp              | file   | file   |   34.82 |     36.3 |
+| sharp              | buffer | buffer |   35.41 |     36.9 |
 
-Greater performance can be expected with caching enabled (default) and using 8+ core machines.
+Greater libvips performance can be expected with caching enabled (default)
+and using 8+ core machines, especially those with larger L1/L2 CPU caches.
 
 The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
 
-### Benchmark test prerequisites
+## Running the benchmark test
 
-Requires both _ImageMagick_ and _GraphicsMagick_:
-
-```sh
-brew install imagemagick
-brew install graphicsmagick
-```
-
-```sh
-sudo apt-get install imagemagick libmagick++-dev graphicsmagick
-```
-
-```sh
-sudo yum install ImageMagick-devel ImageMagick-c++-devel GraphicsMagick
-```
-
-### Running the benchmark test
+Requires Docker.
 
 ```sh
 git clone https://github.com/lovell/sharp.git
-cd sharp
-npm install
-cd test/bench
-npm install
-npm test
+cd sharp/test/bench
+./run-with-docker.sh
 ```

docs/robots.txt

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

docs/search-index/build.js

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

docs/search-index/extract.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const stopWords = require('./stop-words');
+
+const extractDescription = (str) =>
+  str
+    .replace(/### Examples.*/sg, '')
+    .replace(/\(http[^)]+/g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/[^A-Za-z0-9_/\-,. ]/g, '')
+    .replace(/\s+/g, ' ')
+    .substring(0, 200)
+    .trim();
+
+const extractParameters = (str) =>
+  [...str.matchAll(/options\.(?<name>[^.`]+)/gs)]
+    .map((match) => match.groups.name)
+    .join(' ');
+
+const extractKeywords = (str) =>
+  [
+    ...new Set(
+      str
+        .split(/[ -/]/)
+        .map((word) => word.toLowerCase().replace(/[^a-z]/g, ''))
+        .filter((word) => word.length > 2 && word.length < 15 && !stopWords.includes(word))
+    )
+  ].join(' ');
+
+module.exports = { extractDescription, extractKeywords, extractParameters };

docs/search-index/stop-words.js

@@ -0,0 +1,120 @@
+'use strict';
+
+module.exports = [
+  'about',
+  'after',
+  'all',
+  'allows',
+  'already',
+  'also',
+  'alternative',
+  'always',
+  'and',
+  'any',
+  'are',
+  'based',
+  'been',
+  'before',
+  'both',
+  'call',
+  'callback',
+  'can',
+  'containing',
+  'contains',
+  'created',
+  'current',
+  'date',
+  'default',
+  'does',
+  'each',
+  'either',
+  'ensure',
+  'entirely',
+  'etc',
+  'every',
+  'except',
+  'following',
+  'for',
+  'from',
+  'get',
+  'gets',
+  'given',
+  'has',
+  'have',
+  'how',
+  'image',
+  'implies',
+  'include',
+  'including',
+  'involve',
+  'its',
+  'last',
+  'least',
+  'lots',
+  'make',
+  'may',
+  'more',
+  'most',
+  'much',
+  'must',
+  'non',
+  'not',
+  'occur',
+  'occurs',
+  'options',
+  'other',
+  'out',
+  'over',
+  'perform',
+  'performs',
+  'produce',
+  'provide',
+  'provided',
+  'ready',
+  'requires',
+  'requiresharp',
+  'returned',
+  'same',
+  'see',
+  'set',
+  'sets',
+  'should',
+  'since',
+  'site',
+  'some',
+  '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',
+  'will',
+  'with',
+  'without',
+  'you'
+];

index.js

@@ -1,877 +0,0 @@
-'use strict';
-
-var path = require('path');
-var util = require('util');
-var stream = require('stream');
-var events = require('events');
-
-var semver = require('semver');
-var color = require('color');
-var BluebirdPromise = require('bluebird');
-
-var sharp = require('./build/Release/sharp');
-
-// Versioning
-var versions = {
-  vips: sharp.libvipsVersion()
-};
-(function() {
-  // Does libvips meet minimum requirement?
-  var libvipsVersionMin = require('./package.json').config.libvips;
-  if (semver.lt(versions.vips, libvipsVersionMin)) {
-    throw new Error('Found libvips ' + versions.vips + ' but require at least ' + libvipsVersionMin);
-  }
-  // Include versions of dependencies, if present
-  try {
-    versions = require('./lib/versions.json');
-  } catch (err) {}
-})();
-
-// Limits
-var maximum = {
-  width: 0x3FFF,
-  height: 0x3FFF,
-  pixels: Math.pow(0x3FFF, 2)
-};
-
-// Constructor-factory
-var Sharp = function(input) {
-  if (!(this instanceof Sharp)) {
-    return new Sharp(input);
-  }
-  stream.Duplex.call(this);
-  this.options = {
-    // input options
-    bufferIn: null,
-    streamIn: false,
-    sequentialRead: false,
-    limitInputPixels: maximum.pixels,
-    // ICC profiles
-    iccProfilePath: path.join(__dirname, 'icc') + path.sep,
-    // resize options
-    topOffsetPre: -1,
-    leftOffsetPre: -1,
-    widthPre: -1,
-    heightPre: -1,
-    topOffsetPost: -1,
-    leftOffsetPost: -1,
-    widthPost: -1,
-    heightPost: -1,
-    width: -1,
-    height: -1,
-    canvas: 'crop',
-    gravity: 0,
-    angle: 0,
-    rotateBeforePreExtract: false,
-    flip: false,
-    flop: false,
-    withoutEnlargement: false,
-    interpolator: 'bicubic',
-    // operations
-    background: [0, 0, 0, 255],
-    flatten: false,
-    negate: false,
-    blurSigma: 0,
-    sharpenRadius: 0,
-    sharpenFlat: 1,
-    sharpenJagged: 2,
-    threshold: 0,
-    gamma: 0,
-    greyscale: false,
-    normalize: 0,
-    // overlay
-    overlayPath: '',
-    // output options
-    output: '__input',
-    progressive: false,
-    quality: 80,
-    compressionLevel: 6,
-    withoutAdaptiveFiltering: false,
-    withoutChromaSubsampling: false,
-    trellisQuantisation: false,
-    overshootDeringing: false,
-    optimiseScans: false,
-    streamOut: false,
-    withMetadata: false,
-    withMetadataOrientation: -1,
-    tileSize: 256,
-    tileOverlap: 0,
-    // Function to notify of queue length changes
-    queueListener: function(queueLength) {
-      module.exports.queue.emit('change', queueLength);
-    }
-  };
-  if (typeof input === 'string') {
-    // input=file
-    this.options.fileIn = input;
-  } else if (typeof input === 'object' && input instanceof Buffer) {
-    // input=buffer
-    this.options.bufferIn = input;
-  } else if (typeof input === 'undefined') {
-    // input=stream
-    this.options.streamIn = true;
-  } else {
-    throw new Error('Unsupported input ' + typeof input);
-  }
-  return this;
-};
-module.exports = Sharp;
-util.inherits(Sharp, stream.Duplex);
-
-/*
-  EventEmitter singleton emits queue length 'change' events
-*/
-module.exports.queue = new events.EventEmitter();
-
-/*
-  Supported image formats
-*/
-module.exports.format = sharp.format();
-
-/*
-  Version numbers of libvips and its dependencies
-*/
-module.exports.versions = versions;
-
-/*
-  Handle incoming chunk on Writable Stream
-*/
-Sharp.prototype._write = function(chunk, encoding, callback) {
-  /*jslint unused: false */
-  if (this.options.streamIn) {
-    if (typeof chunk === 'object' && chunk instanceof Buffer) {
-      if (this.options.bufferIn instanceof Buffer) {
-        // Append to existing Buffer
-        this.options.bufferIn = Buffer.concat(
-          [this.options.bufferIn, chunk],
-          this.options.bufferIn.length + chunk.length
-        );
-      } else {
-        // Create new Buffer
-        this.options.bufferIn = new Buffer(chunk.length);
-        chunk.copy(this.options.bufferIn);
-      }
-      callback();
-    } else {
-      callback(new Error('Non-Buffer data on Writable Stream'));
-    }
-  } else {
-    callback(new Error('Unexpected data on Writable Stream'));
-  }
-};
-
-// Crop this part of the resized image (Center/Centre, North, East, South, West)
-module.exports.gravity = {
-  'center': 0,
-  'centre': 0,
-  'north': 1,
-  'east': 2,
-  'south': 3,
-  'west': 4,
-  'northeast': 5,
-  'southeast': 6,
-  'southwest': 7,
-  'northwest': 8
-};
-
-Sharp.prototype.crop = function(gravity) {
-  this.options.canvas = 'crop';
-  if (typeof gravity === 'number' && !Number.isNaN(gravity) && gravity >= 0 && gravity <= 8) {
-    this.options.gravity = gravity;
-  } else if (typeof gravity === 'string' && typeof module.exports.gravity[gravity] === 'number') {
-    this.options.gravity = module.exports.gravity[gravity];
-  } else {
-    throw new Error('Unsupported crop gravity ' + gravity);
-  }
-  return this;
-};
-
-Sharp.prototype.extract = function(options) {
-  if (!options || typeof options !== 'object') {
-    // Legacy extract(top,left,width,height) syntax
-    options = {
-      left: arguments[1],
-      top: arguments[0],
-      width: arguments[2],
-      height: arguments[3]
-    };
-  }
-  var suffix = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
-  ['left', 'top', 'width', 'height'].forEach(function (name) {
-    var value = options[name];
-    if (typeof value === 'number' && !Number.isNaN(value) && value % 1 === 0 && value >= 0) {
-      this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
-    } else {
-      throw new Error('Non-integer value for ' + name + ' of ' + value);
-    }
-  }, this);
-  // Ensure existing rotation occurs before pre-resize extraction
-  if (suffix === 'Pre' && this.options.angle !== 0) {
-    this.options.rotateBeforePreExtract = true;
-  }
-  return this;
-};
-
-/*
-  Set the background colour for embed and flatten operations.
-  Delegates to the 'Color' module, which can throw an Error
-  but is liberal in what it accepts, clamping values to sensible min/max.
-*/
-Sharp.prototype.background = function(rgba) {
-  var colour = color(rgba);
-  this.options.background = colour.rgbArray();
-  this.options.background.push(colour.alpha() * 255);
-  return this;
-};
-
-Sharp.prototype.embed = function() {
-  this.options.canvas = 'embed';
-  return this;
-};
-
-Sharp.prototype.max = function() {
-  this.options.canvas = 'max';
-  return this;
-};
-
-Sharp.prototype.min = function() {
-  this.options.canvas = 'min';
-  return this;
-};
-
-/*
-  Ignoring the aspect ratio of the input, stretch the image to
-  the exact width and/or height provided via the resize method.
-*/
-Sharp.prototype.ignoreAspectRatio = function() {
-  this.options.canvas = 'ignore_aspect';
-  return this;
-};
-
-Sharp.prototype.flatten = function(flatten) {
-  this.options.flatten = (typeof flatten === 'boolean') ? flatten : true;
-  return this;
-};
-
-Sharp.prototype.negate = function(negate) {
-  this.options.negate = (typeof negate === 'boolean') ? negate : true;
-  return this;
-};
-
-Sharp.prototype.overlayWith = function(overlayPath) {
-  if (typeof overlayPath !== 'string') {
-    throw new Error('The overlay path must be a string');
-  }
-  if (overlayPath === '') {
-    throw new Error('The overlay path cannot be empty');
-  }
-  this.options.overlayPath = overlayPath;
-  return this;
-};
-
-/*
-  Rotate output image by 0, 90, 180 or 270 degrees
-  Auto-rotation based on the EXIF Orientation tag is represented by an angle of -1
-*/
-Sharp.prototype.rotate = function(angle) {
-  if (typeof angle === 'undefined') {
-    this.options.angle = -1;
-  } else if (!Number.isNaN(angle) && [0, 90, 180, 270].indexOf(angle) !== -1) {
-    this.options.angle = angle;
-  } else {
-    throw new Error('Unsupported angle (0, 90, 180, 270) ' + angle);
-  }
-  return this;
-};
-
-/*
-  Flip the image vertically, about the Y axis
-*/
-Sharp.prototype.flip = function(flip) {
-  this.options.flip = (typeof flip === 'boolean') ? flip : true;
-  return this;
-};
-
-/*
-  Flop the image horizontally, about the X axis
-*/
-Sharp.prototype.flop = function(flop) {
-  this.options.flop = (typeof flop === 'boolean') ? flop : true;
-  return this;
-};
-
-/*
-  Do not enlarge the output if the input width *or* height are already less than the required dimensions
-  This is equivalent to GraphicsMagick's ">" geometry option:
-    "change the dimensions of the image only if its width or height exceeds the geometry specification"
-*/
-Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
-  this.options.withoutEnlargement = (typeof withoutEnlargement === 'boolean') ? withoutEnlargement : true;
-  return this;
-};
-
-/*
-  Blur the output image.
-  Call without a sigma to use a fast, mild blur.
-  Call with a sigma to use a slower, more accurate Gaussian blur.
-*/
-Sharp.prototype.blur = function(sigma) {
-  if (typeof sigma === 'undefined') {
-    // No arguments: default to mild blur
-    this.options.blurSigma = -1;
-  } else if (typeof sigma === 'boolean') {
-    // Boolean argument: apply mild blur?
-    this.options.blurSigma = sigma ? -1 : 0;
-  } else if (typeof sigma === 'number' && !Number.isNaN(sigma) && sigma >= 0.3 && sigma <= 1000) {
-    // Numeric argument: specific sigma
-    this.options.blurSigma = sigma;
-  } else {
-    throw new Error('Invalid blur sigma (0.3 to 1000.0) ' + sigma);
-  }
-  return this;
-};
-
-/*
-  Sharpen the output image.
-  Call without a radius to use a fast, mild sharpen.
-  Call with a radius to use a slow, accurate sharpen using the L of LAB colour space.
-    radius - size of mask in pixels, must be integer
-    flat - level of "flat" area sharpen, default 1
-    jagged - level of "jagged" area sharpen, default 2
-*/
-Sharp.prototype.sharpen = function(radius, flat, jagged) {
-  if (typeof radius === 'undefined') {
-    // No arguments: default to mild sharpen
-    this.options.sharpenRadius = -1;
-  } else if (typeof radius === 'boolean') {
-    // Boolean argument: apply mild sharpen?
-    this.options.sharpenRadius = radius ? -1 : 0;
-  } else if (typeof radius === 'number' && !Number.isNaN(radius) && (radius % 1 === 0) && radius >= 1) {
-    // Numeric argument: specific radius
-    this.options.sharpenRadius = radius;
-    // Control over flat areas
-    if (typeof flat !== 'undefined' && flat !== null) {
-      if (typeof flat === 'number' && !Number.isNaN(flat) && flat >= 0) {
-        this.options.sharpenFlat = flat;
-      } else {
-        throw new Error('Invalid sharpen level for flat areas ' + flat + ' (expected >= 0)');
-      }
-    }
-    // Control over jagged areas
-    if (typeof jagged !== 'undefined' && jagged !== null) {
-      if (typeof jagged === 'number' && !Number.isNaN(jagged) && jagged >= 0) {
-        this.options.sharpenJagged = jagged;
-      } else {
-        throw new Error('Invalid sharpen level for jagged areas ' + jagged + ' (expected >= 0)');
-      }
-    }
-  } else {
-    throw new Error('Invalid sharpen radius ' + radius + ' (expected integer >= 1)');
-  }
-  return this;
-};
-
-Sharp.prototype.threshold = function(threshold) {
-  if (typeof threshold === 'undefined') {
-    this.options.threshold = 128;
-  } else if (typeof threshold === 'boolean') {
-    this.options.threshold = threshold ? 128 : 0;
-  } else if (typeof threshold === 'number' && !Number.isNaN(threshold) && (threshold % 1 === 0) && threshold >= 0 && threshold <= 255) {
-    this.options.threshold = threshold;
-  } else {
-    throw new Error('Invalid threshold (0 to 255) ' + threshold);
-  }
-  return this;
-};
-
-/*
-  Set the interpolator to use for the affine transformation
-*/
-module.exports.interpolator = {
-  nearest: 'nearest',
-  bilinear: 'bilinear',
-  bicubic: 'bicubic',
-  nohalo: 'nohalo',
-  locallyBoundedBicubic: 'lbb',
-  vertexSplitQuadraticBasisSpline: 'vsqbs'
-};
-Sharp.prototype.interpolateWith = function(interpolator) {
-  var isValid = false;
-  for (var key in module.exports.interpolator) {
-    if (module.exports.interpolator[key] === interpolator) {
-      isValid = true;
-      break;
-    }
-  }
-  if (isValid) {
-    this.options.interpolator = interpolator;
-  } else {
-    throw new Error('Invalid interpolator ' + interpolator);
-  }
-  return this;
-};
-
-/*
-  Darken image pre-resize (1/gamma) and brighten post-resize (gamma).
-  Improves brightness of resized image in non-linear colour spaces.
-*/
-Sharp.prototype.gamma = function(gamma) {
-  if (typeof gamma === 'undefined') {
-    // Default gamma correction of 2.2 (sRGB)
-    this.options.gamma = 2.2;
-  } else if (!Number.isNaN(gamma) && gamma >= 1 && gamma <= 3) {
-    this.options.gamma = gamma;
-  } else {
-    throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
-  }
-  return this;
-};
-
-/*
-  Enhance output image contrast by stretching its luminance to cover the full dynamic range
-*/
-Sharp.prototype.normalize = function(normalize) {
-  this.options.normalize = (typeof normalize === 'boolean') ? normalize : true;
-  return this;
-};
-Sharp.prototype.normalise = Sharp.prototype.normalize;
-
-/*
-  Convert to greyscale
-*/
-Sharp.prototype.greyscale = function(greyscale) {
-  this.options.greyscale = (typeof greyscale === 'boolean') ? greyscale : true;
-  return this;
-};
-Sharp.prototype.grayscale = Sharp.prototype.greyscale;
-
-Sharp.prototype.progressive = function(progressive) {
-  this.options.progressive = (typeof progressive === 'boolean') ? progressive : true;
-  return this;
-};
-
-Sharp.prototype.sequentialRead = function(sequentialRead) {
-  this.options.sequentialRead = (typeof sequentialRead === 'boolean') ? sequentialRead : true;
-  return this;
-};
-
-Sharp.prototype.quality = function(quality) {
-  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100 && quality % 1 === 0) {
-    this.options.quality = quality;
-  } else {
-    throw new Error('Invalid quality (1 to 100) ' + quality);
-  }
-  return this;
-};
-
-/*
-  zlib compression level for PNG output
-*/
-Sharp.prototype.compressionLevel = function(compressionLevel) {
-  if (!Number.isNaN(compressionLevel) && compressionLevel >= 0 && compressionLevel <= 9) {
-    this.options.compressionLevel = compressionLevel;
-  } else {
-    throw new Error('Invalid compressionLevel (0 to 9) ' + compressionLevel);
-  }
-  return this;
-};
-
-/*
-  Disable the use of adaptive row filtering for PNG output
-*/
-Sharp.prototype.withoutAdaptiveFiltering = function(withoutAdaptiveFiltering) {
-  this.options.withoutAdaptiveFiltering = (typeof withoutAdaptiveFiltering === 'boolean') ? withoutAdaptiveFiltering : true;
-  return this;
-};
-
-/*
-  Disable the use of chroma subsampling for JPEG output
-*/
-Sharp.prototype.withoutChromaSubsampling = function(withoutChromaSubsampling) {
-  this.options.withoutChromaSubsampling = (typeof withoutChromaSubsampling === 'boolean') ? withoutChromaSubsampling : true;
-  return this;
-};
-
-/*
-  Apply trellis quantisation to JPEG output - requires mozjpeg 3.0+
-*/
-Sharp.prototype.trellisQuantisation = function(trellisQuantisation) {
-  this.options.trellisQuantisation = (typeof trellisQuantisation === 'boolean') ? trellisQuantisation : true;
-  return this;
-};
-Sharp.prototype.trellisQuantization = Sharp.prototype.trellisQuantisation;
-
-/*
-  Apply overshoot deringing to JPEG output - requires mozjpeg 3.0+
-*/
-Sharp.prototype.overshootDeringing = function(overshootDeringing) {
-  this.options.overshootDeringing = (typeof overshootDeringing === 'boolean') ? overshootDeringing : true;
-  return this;
-};
-
-/*
-  Optimise scans in progressive JPEG output - requires mozjpeg 3.0+
-*/
-Sharp.prototype.optimiseScans = function(optimiseScans) {
-  this.options.optimiseScans = (typeof optimiseScans === 'boolean') ? optimiseScans : true;
-  if (this.options.optimiseScans) {
-    this.progressive();
-  }
-  return this;
-};
-Sharp.prototype.optimizeScans = Sharp.prototype.optimiseScans;
-
-/*
-  Include all metadata (EXIF, XMP, IPTC) from the input image in the output image
-  Optionally provide an Object with attributes to update:
-    orientation: numeric value for EXIF Orientation tag
-*/
-Sharp.prototype.withMetadata = function(withMetadata) {
-  this.options.withMetadata = (typeof withMetadata === 'boolean') ? withMetadata : true;
-  if (typeof withMetadata === 'object') {
-    if ('orientation' in withMetadata) {
-      if (
-        typeof withMetadata.orientation === 'number' &&
-        !Number.isNaN(withMetadata.orientation) &&
-        withMetadata.orientation % 1 === 0 &&
-        withMetadata.orientation >= 0 &&
-        withMetadata.orientation <= 7
-      ) {
-        this.options.withMetadataOrientation = withMetadata.orientation;
-      } else {
-        throw new Error('Invalid orientation (0 to 7) ' + withMetadata.orientation);
-      }
-    }
-  }
-  return this;
-};
-
-/*
-  Tile size and overlap for Deep Zoom output
-*/
-Sharp.prototype.tile = function(size, overlap) {
-  // Size of square tiles, in pixels
-  if (typeof size !== 'undefined' && size !== null) {
-    if (!Number.isNaN(size) && size % 1 === 0 && size >= 1 && size <= 8192) {
-      this.options.tileSize = size;
-    } else {
-      throw new Error('Invalid tile size (1 to 8192) ' + size);
-    }
-  }
-  // Overlap of tiles, in pixels
-  if (typeof overlap !== 'undefined' && overlap !== null) {
-    if (!Number.isNaN(overlap) && overlap % 1 === 0 && overlap >= 0 && overlap <= 8192) {
-      if (overlap > this.options.tileSize) {
-        throw new Error('Tile overlap ' + overlap + ' cannot be larger than tile size ' + this.options.tileSize);
-      }
-      this.options.tileOverlap = overlap;
-    } else {
-      throw new Error('Invalid tile overlap (0 to 8192) ' + overlap);
-    }
-  }
-  return this;
-};
-
-Sharp.prototype.resize = function(width, height) {
-  if (!width) {
-    this.options.width = -1;
-  } else {
-    if (typeof width === 'number' && !Number.isNaN(width) && width % 1 === 0 && width > 0 && width <= maximum.width) {
-      this.options.width = width;
-    } else {
-      throw new Error('Invalid width (1 to ' + maximum.width + ') ' + width);
-    }
-  }
-  if (!height) {
-    this.options.height = -1;
-  } else {
-    if (typeof height === 'number' && !Number.isNaN(height) && height % 1 === 0 && height > 0 && height <= maximum.height) {
-      this.options.height = height;
-    } else {
-      throw new Error('Invalid height (1 to ' + maximum.height + ') ' + height);
-    }
-  }
-  return this;
-};
-
-/*
-  Limit the total number of pixels for input images
-  Assumes the image dimensions contained in the file header can be trusted
-*/
-Sharp.prototype.limitInputPixels = function(limit) {
-  if (typeof limit === 'number' && !Number.isNaN(limit) && limit % 1 === 0 && limit > 0) {
-    this.options.limitInputPixels = limit;
-  } else {
-    throw new Error('Invalid pixel limit (1 to ' + maximum.pixels + ') ' + limit);
-  }
-  return this;
-};
-
-/*
-  Write output image data to a file
-*/
-Sharp.prototype.toFile = function(output, callback) {
-  if (!output || output.length === 0) {
-    var errOutputInvalid = new Error('Invalid output');
-    if (typeof callback === 'function') {
-      callback(errOutputInvalid);
-    } else {
-      return BluebirdPromise.reject(errOutputInvalid);
-    }
-  } else {
-    if (this.options.fileIn === output) {
-      var errOutputIsInput = new Error('Cannot use same file for input and output');
-      if (typeof callback === 'function') {
-        callback(errOutputIsInput);
-      } else {
-        return BluebirdPromise.reject(errOutputIsInput);
-      }
-    } else {
-      this.options.output = output;
-      return this._pipeline(callback);
-    }
-  }
-  return this;
-};
-
-/*
-  Write output to a Buffer
-*/
-Sharp.prototype.toBuffer = function(callback) {
-  return this._pipeline(callback);
-};
-
-/*
-  Force JPEG output
-*/
-Sharp.prototype.jpeg = function() {
-  this.options.output = '__jpeg';
-  return this;
-};
-
-/*
-  Force PNG output
-*/
-Sharp.prototype.png = function() {
-  this.options.output = '__png';
-  return this;
-};
-
-/*
-  Force WebP output
-*/
-Sharp.prototype.webp = function() {
-  this.options.output = '__webp';
-  return this;
-};
-
-/*
-  Force raw, uint8 output
-*/
-Sharp.prototype.raw = function() {
-  this.options.output = '__raw';
-  return this;
-};
-
-/*
-  Force output to a given format
-  @param format is either the id as a String or an Object with an 'id' attribute
-*/
-Sharp.prototype.toFormat = function(format) {
-  var id = format;
-  if (typeof format === 'object') {
-    id = format.id;
-  }
-  if (typeof id === 'string' && typeof module.exports.format[id] === 'object' && typeof this[id] === 'function') {
-    this[id]();
-  } else {
-    throw new Error('Unsupported format ' + format);
-  }
-  return this;
-};
-
-/*
-  Used by a Writable Stream to notify that it is ready for data
-*/
-Sharp.prototype._read = function() {
-  if (!this.options.streamOut) {
-    this.options.streamOut = true;
-    this._pipeline();
-  }
-};
-
-/*
-  Invoke the C++ image processing pipeline
-  Supports callback, stream and promise variants
-*/
-Sharp.prototype._pipeline = function(callback) {
-  var that = this;
-  if (typeof callback === 'function') {
-    // output=file/buffer
-    if (this.options.streamIn) {
-      // output=file/buffer, input=stream
-      this.on('finish', function() {
-        sharp.pipeline(that.options, callback);
-      });
-    } else {
-      // output=file/buffer, input=file/buffer
-      sharp.pipeline(this.options, callback);
-    }
-    return this;
-  } else if (this.options.streamOut) {
-    // output=stream
-    if (this.options.streamIn) {
-      // output=stream, input=stream
-      this.on('finish', function() {
-        sharp.pipeline(that.options, function(err, data) {
-          if (err) {
-            that.emit('error', err);
-          } else {
-            that.push(data);
-          }
-          that.push(null);
-        });
-      });
-    } else {
-      // output=stream, input=file/buffer
-      sharp.pipeline(this.options, function(err, data) {
-        if (err) {
-          that.emit('error', err);
-        } else {
-          that.push(data);
-        }
-        that.push(null);
-      });
-    }
-    return this;
-  } else {
-    // output=promise
-    if (this.options.streamIn) {
-      // output=promise, input=stream
-      return new BluebirdPromise(function(resolve, reject) {
-        that.on('finish', function() {
-          sharp.pipeline(that.options, function(err, data) {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(data);
-            }
-          });
-        });
-      });
-    } else {
-      // output=promise, input=file/buffer
-      return new BluebirdPromise(function(resolve, reject) {
-        sharp.pipeline(that.options, function(err, data) {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(data);
-          }
-        });
-      });
-    }
-  }
-};
-
-/*
-  Reads the image header and returns metadata
-  Supports callback, stream and promise variants
-*/
-Sharp.prototype.metadata = function(callback) {
-  var that = this;
-  if (typeof callback === 'function') {
-    if (this.options.streamIn) {
-      this.on('finish', function() {
-        sharp.metadata(that.options, callback);
-      });
-    } else {
-      sharp.metadata(this.options, callback);
-    }
-    return this;
-  } else {
-    if (this.options.streamIn) {
-      return new BluebirdPromise(function(resolve, reject) {
-        that.on('finish', function() {
-          sharp.metadata(that.options, function(err, metadata) {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(metadata);
-            }
-          });
-        });
-      });
-    } else {
-      return new BluebirdPromise(function(resolve, reject) {
-        sharp.metadata(that.options, function(err, metadata) {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(metadata);
-          }
-        });
-      });
-    }
-  }
-};
-
-/*
-  Clone new instance using existing options.
-  Cloned instances share the same input.
-*/
-Sharp.prototype.clone = function() {
-  // Clone existing options
-  var clone = new Sharp();
-  util._extend(clone.options, this.options);
-  clone.streamIn = false;
-  // Pass 'finish' event to clone for Stream-based input
-  this.on('finish', function() {
-    // Clone inherits input data
-    clone.options.bufferIn = this.options.bufferIn;
-    clone.emit('finish');
-  });
-  return clone;
-};
-
-/*
-  Get and set cache memory and item limits
-*/
-module.exports.cache = function(memory, items) {
-  if (typeof memory !== 'number' || Number.isNaN(memory)) {
-    memory = null;
-  }
-  if (typeof items !== 'number' || Number.isNaN(items)) {
-    items = null;
-  }
-  return sharp.cache(memory, items);
-};
-
-/*
-  Get and set size of thread pool
-*/
-module.exports.concurrency = function(concurrency) {
-  if (typeof concurrency !== 'number' || Number.isNaN(concurrency)) {
-    concurrency = null;
-  }
-  return sharp.concurrency(concurrency);
-};
-
-/*
-  Get internal counters
-*/
-module.exports.counters = function() {
-  return sharp.counters();
-};
-
-/*
-  Get and set use of SIMD vector unit instructions
-*/
-module.exports.simd = function(simd) {
-  if (typeof simd !== 'boolean') {
-    simd = null;
-  }
-  return sharp.simd(simd);
-};
-// Switch off default
-module.exports.simd(false);

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

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

install/libvips.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const fs = require('fs');
+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 semverLessThan = require('semver/functions/lt');
+const semverSatisfies = require('semver/functions/satisfies');
+const simpleGet = require('simple-get');
+const tarFs = require('tar-fs');
+
+const agent = require('../lib/agent');
+const libvips = require('../lib/libvips');
+const platform = require('../lib/platform');
+
+const minimumGlibcVersionByArch = {
+  arm: '2.28',
+  arm64: '2.17',
+  x64: '2.17'
+};
+
+const hasSharpPrebuild = [
+  'darwin-x64',
+  'darwin-arm64',
+  'linux-arm64',
+  'linux-x64',
+  'linuxmusl-x64',
+  'linuxmusl-arm64',
+  'win32-ia32',
+  'win32-x64'
+];
+
+const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
+const localLibvipsDir = process.env.npm_config_sharp_libvips_local_prebuilds || '';
+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 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?');
+    libvips.log('- For npm <= v6, try again with the "--unsafe-perm" flag');
+    libvips.log('- For npm >= v8, the user must own the directory "npm install" is run in');
+  }
+  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 versionedVendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, platformAndArch);
+  libvips.mkdirSync(versionedVendorPath);
+
+  const ignoreVendorInclude = hasSharpPrebuild.includes(platformAndArch) && !process.env.npm_config_build_from_source;
+  const ignore = function (name) {
+    return ignoreVendorInclude && name.includes('include/');
+  };
+
+  stream.pipeline(
+    fs.createReadStream(tarPath),
+    verifyIntegrity(platformAndArch),
+    new zlib.BrotliDecompress(),
+    tarFs.extract(versionedVendorPath, { ignore }),
+    function (err) {
+      if (err) {
+        if (/unexpected end of file/.test(err.message)) {
+          fail(new Error(`Please delete ${tarPath} as it is not a valid tarball`));
+        }
+        fail(err);
+      }
+    }
+  );
+};
+
+try {
+  const useGlobalLibvips = libvips.useGlobalLibvips();
+
+  if (useGlobalLibvips) {
+    const globalLibvipsVersion = libvips.globalLibvipsVersion();
+    libvips.log(`Detected globally-installed libvips v${globalLibvipsVersion}`);
+    libvips.log('Building from source via node-gyp');
+    process.exit(1);
+  } else if (libvips.hasVendoredLibvips()) {
+    libvips.log(`Using existing vendored libvips v${minimumLibvipsVersion}`);
+  } else {
+    // Is this arch/platform supported?
+    const arch = process.env.npm_config_arch || process.arch;
+    const platformAndArch = platform();
+    if (arch === 'ia32' && !platformAndArch.startsWith('win32')) {
+      throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
+    }
+    if (platformAndArch === 'darwin-arm64') {
+      throw new Error("Please run 'brew install vips' to install libvips on Apple M1 (ARM64) systems");
+    }
+    if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
+      throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
+    }
+    // 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 (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 (!semverSatisfies(process.versions.node, supportedNodeVersion)) {
+      handleError(new Error(`Expected Node.js version ${supportedNodeVersion} but found ${process.versions.node}`));
+    }
+
+    // Download to per-process temporary file
+    const tarFilename = ['libvips', minimumLibvipsVersionLabelled, platformAndArch].join('-') + '.tar.br';
+    const tarPathCache = path.join(libvips.cachePath(), tarFilename);
+    if (fs.existsSync(tarPathCache)) {
+      libvips.log(`Using cached ${tarPathCache}`);
+      extractTarball(tarPathCache, platformAndArch);
+    } else if (localLibvipsDir) {
+      // If localLibvipsDir is given try to use binaries from local directory
+      const tarPathLocal = path.join(path.resolve(localLibvipsDir), `v${minimumLibvipsVersionLabelled}`, tarFilename);
+      libvips.log(`Using local libvips from ${tarPathLocal}`);
+      extractTarball(tarPathLocal, platformAndArch);
+    } else {
+      const url = distBaseUrl + tarFilename;
+      libvips.log(`Downloading ${url}`);
+      simpleGet({ url: url, agent: agent() }, function (err, response) {
+        if (err) {
+          fail(err);
+        } else if (response.statusCode === 404) {
+          fail(new Error(`Prebuilt libvips ${minimumLibvipsVersion} binaries are not yet available for ${platformAndArch}`));
+        } else if (response.statusCode !== 200) {
+          fail(new Error(`Status ${response.statusCode} ${response.statusMessage}`));
+        } else {
+          const tarPathTemp = path.join(os.tmpdir(), `${process.pid}-${tarFilename}`);
+          const tmpFileStream = fs.createWriteStream(tarPathTemp);
+          response
+            .on('error', function (err) {
+              tmpFileStream.destroy(err);
+            })
+            .on('close', function () {
+              if (!response.complete) {
+                tmpFileStream.destroy(new Error('Download incomplete (connection was terminated)'));
+              }
+            })
+            .pipe(tmpFileStream);
+          tmpFileStream
+            .on('error', function (err) {
+              // Clean up temporary file
+              try {
+                fs.unlinkSync(tarPathTemp);
+              } catch (e) {}
+              fail(err);
+            })
+            .on('close', function () {
+              try {
+                // Attempt to rename
+                fs.renameSync(tarPathTemp, tarPathCache);
+              } catch (err) {
+                // Fall back to copy and unlink
+                fs.copyFileSync(tarPathTemp, tarPathCache);
+                fs.unlinkSync(tarPathTemp);
+              }
+              extractTarball(tarPathCache, platformAndArch);
+            });
+        }
+      });
+    }
+  }
+} catch (err) {
+  fail(err);
+}

lib/agent.js

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

lib/channel.js

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

lib/colour.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const color = require('color');
+const is = require('./is');
+
+/**
+ * Colourspaces.
+ * @private
+ */
+const colourspace = {
+  multiband: 'multiband',
+  'b-w': 'b-w',
+  bw: 'b-w',
+  cmyk: 'cmyk',
+  srgb: 'srgb'
+};
+
+/**
+ * Tint the image using the provided chroma while preserving the image luminance.
+ * An alpha channel may be present and will be unchanged by the operation.
+ *
+ * @example
+ * const output = await sharp(input)
+ *   .tint({ r: 255, g: 240, b: 16 })
+ *   .toBuffer();
+ *
+ * @param {string|Object} rgb - parsed by the [color](https://www.npmjs.org/package/color) module to extract chroma values.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameter
+ */
+function tint (rgb) {
+  const colour = color(rgb);
+  this.options.tintA = colour.a();
+  this.options.tintB = colour.b();
+  return this;
+}
+
+/**
+ * Convert to 8-bit greyscale; 256 shades of grey.
+ * This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
+ * By default the output image will be web-friendly sRGB and contain three (identical) color channels.
+ * This may be overridden by other sharp operations such as `toColourspace('b-w')`,
+ * which will produce an output image containing one color channel.
+ * An alpha channel may be present, and will be unchanged by the operation.
+ *
+ * @example
+ * const output = await sharp(input).greyscale().toBuffer();
+ *
+ * @param {Boolean} [greyscale=true]
+ * @returns {Sharp}
+ */
+function greyscale (greyscale) {
+  this.options.greyscale = is.bool(greyscale) ? greyscale : true;
+  return this;
+}
+
+/**
+ * Alternative spelling of `greyscale`.
+ * @param {Boolean} [grayscale=true]
+ * @returns {Sharp}
+ */
+function grayscale (grayscale) {
+  return this.greyscale(grayscale);
+}
+
+/**
+ * Set the 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.
+ *
+ * @example
+ * // Output 16 bits per pixel RGB
+ * await sharp(input)
+ *  .toColourspace('rgb16')
+ *  .toFile('16-bpp.png')
+ *
+ * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/3c0bfdf74ce1dc37a6429bed47fa76f16e2cd70a/libvips/iofuncs/enumtypes.c#L777-L794)
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function toColourspace (colourspace) {
+  if (!is.string(colourspace)) {
+    throw is.invalidParameterError('colourspace', 'string', colourspace);
+  }
+  this.options.colourspace = colourspace;
+  return this;
+}
+
+/**
+ * Alternative spelling of `toColourspace`.
+ * @param {string} [colorspace] - output colorspace.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function toColorspace (colorspace) {
+  return this.toColourspace(colorspace);
+}
+
+/**
+ * Update a colour attribute of the this.options Object.
+ * @private
+ * @param {string} key
+ * @param {string|Object} value
+ * @throws {Error} Invalid value
+ */
+function _setBackgroundColourOption (key, value) {
+  if (is.defined(value)) {
+    if (is.object(value) || is.string(value)) {
+      const colour = color(value);
+      this.options[key] = [
+        colour.red(),
+        colour.green(),
+        colour.blue(),
+        Math.round(colour.alpha() * 255)
+      ];
+    } else {
+      throw is.invalidParameterError('background', 'object or string', value);
+    }
+  }
+}
+
+/**
+ * Decorate the Sharp prototype with colour-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Public
+    tint,
+    greyscale,
+    grayscale,
+    pipelineColourspace,
+    pipelineColorspace,
+    toColourspace,
+    toColorspace,
+    // Private
+    _setBackgroundColourOption
+  });
+  // Class attributes
+  Sharp.colourspace = colourspace;
+  Sharp.colorspace = colourspace;
+};

lib/composite.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const is = require('./is');
+
+/**
+ * Blend modes.
+ * @member
+ * @private
+ */
+const blend = {
+  clear: 'clear',
+  source: 'source',
+  over: 'over',
+  in: 'in',
+  out: 'out',
+  atop: 'atop',
+  dest: 'dest',
+  'dest-over': 'dest-over',
+  'dest-in': 'dest-in',
+  'dest-out': 'dest-out',
+  'dest-atop': 'dest-atop',
+  xor: 'xor',
+  add: 'add',
+  saturate: 'saturate',
+  multiply: 'multiply',
+  screen: 'screen',
+  overlay: 'overlay',
+  darken: 'darken',
+  lighten: 'lighten',
+  'colour-dodge': 'colour-dodge',
+  'color-dodge': 'colour-dodge',
+  'colour-burn': 'colour-burn',
+  'color-burn': 'colour-burn',
+  'hard-light': 'hard-light',
+  'soft-light': 'soft-light',
+  difference: 'difference',
+  exclusion: 'exclusion'
+};
+
+/**
+ * Composite image(s) over the processed (resized, extracted etc.) image.
+ *
+ * The images to composite must be the same size or smaller than the processed image.
+ * If both `top` and `left` options are provided, they take precedence over `gravity`.
+ *
+ * Any resize or rotate operations in the same processing pipeline
+ * will always be applied to the input image before composition.
+ *
+ * The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+ * `dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+ * `xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+ * `colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+ * `hard-light`, `soft-light`, `difference`, `exclusion`.
+ *
+ * More information about blend modes can be found at
+ * https://www.libvips.org/API/current/libvips-conversion.html#VipsBlendMode
+ * and https://www.cairographics.org/operators/
+ *
+ * @since 0.22.0
+ *
+ * @example
+ * await sharp(background)
+ *   .composite([
+ *     { input: layer1, gravity: 'northwest' },
+ *     { input: layer2, gravity: 'southeast' },
+ *   ])
+ *   .toFile('combined.png');
+ *
+ * @example
+ * const output = await sharp('input.gif', { animated: true })
+ *   .composite([
+ *     { input: 'overlay.png', tile: true, blend: 'saturate' }
+ *   ])
+ *   .toBuffer();
+ *
+ * @example
+ * sharp('input.png')
+ *   .rotate(180)
+ *   .resize(300)
+ *   .flatten( { background: '#ff6600' } )
+ *   .composite([{ input: 'overlay.png', gravity: 'southeast' }])
+ *   .sharpen()
+ *   .withMetadata()
+ *   .webp( { quality: 90 } )
+ *   .toBuffer()
+ *   .then(function(outputBuffer) {
+ *     // outputBuffer contains upside down, 300px wide, alpha channel flattened
+ *     // onto orange background, composited with overlay.png with SE gravity,
+ *     // sharpened, with metadata, 90% quality WebP image data. Phew!
+ *   });
+ *
+ * @param {Object[]} images - Ordered list of images to composite
+ * @param {Buffer|String} [images[].input] - Buffer containing image data, String containing the path to an image file, or Create object (see below)
+ * @param {Object} [images[].input.create] - describes a blank overlay to be created.
+ * @param {Number} [images[].input.create.width]
+ * @param {Number} [images[].input.create.height]
+ * @param {Number} [images[].input.create.channels] - 3-4
+ * @param {String|Object} [images[].input.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [images[].input.text] - describes a new text image to be created.
+ * @param {string} [images[].input.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+ * @param {string} [images[].input.text.font] - font name to render with.
+ * @param {string} [images[].input.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
+ * @param {number} [images[].input.text.width=0] - integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
+ * @param {number} [images[].input.text.height=0] - integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
+ * @param {string} [images[].input.text.align='left'] - text alignment (`'left'`, `'centre'`, `'center'`, `'right'`).
+ * @param {boolean} [images[].input.text.justify=false] - set this to true to apply justification to the text.
+ * @param {number} [images[].input.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
+ * @param {boolean} [images[].input.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`.
+ * @param {number} [images[].input.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
+ * @param {String} [images[].blend='over'] - how to blend this image with the image below.
+ * @param {String} [images[].gravity='centre'] - gravity at which to place the overlay.
+ * @param {Number} [images[].top] - the pixel offset from the top edge.
+ * @param {Number} [images[].left] - the pixel offset from the left edge.
+ * @param {Boolean} [images[].tile=false] - set to true to repeat the overlay image across the entire image with the given `gravity`.
+ * @param {Boolean} [images[].premultiplied=false] - set to true to avoid premultipling the image below. Equivalent to the `--premultiplied` vips option.
+ * @param {Number} [images[].density=72] - number representing the DPI for vector overlay image.
+ * @param {Object} [images[].raw] - describes overlay when using raw pixel data.
+ * @param {Number} [images[].raw.width]
+ * @param {Number} [images[].raw.height]
+ * @param {Number} [images[].raw.channels]
+ * @param {boolean} [images[].animated=false] - Set to `true` to read all frames/pages of an animated image.
+ * @param {string} [images[].failOn='warning'] - @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
+ */
+function composite (images) {
+  if (!Array.isArray(images)) {
+    throw is.invalidParameterError('images to composite', 'array', images);
+  }
+  this.options.composite = images.map(image => {
+    if (!is.object(image)) {
+      throw is.invalidParameterError('image to composite', 'object', image);
+    }
+    const inputOptions = this._inputOptionsFromObject(image);
+    const composite = {
+      input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
+      blend: 'over',
+      tile: false,
+      left: 0,
+      top: 0,
+      hasOffset: false,
+      gravity: 0,
+      premultiplied: false
+    };
+    if (is.defined(image.blend)) {
+      if (is.string(blend[image.blend])) {
+        composite.blend = blend[image.blend];
+      } else {
+        throw is.invalidParameterError('blend', 'valid blend name', image.blend);
+      }
+    }
+    if (is.defined(image.tile)) {
+      if (is.bool(image.tile)) {
+        composite.tile = image.tile;
+      } else {
+        throw is.invalidParameterError('tile', 'boolean', image.tile);
+      }
+    }
+    if (is.defined(image.left)) {
+      if (is.integer(image.left)) {
+        composite.left = image.left;
+      } else {
+        throw is.invalidParameterError('left', 'integer', image.left);
+      }
+    }
+    if (is.defined(image.top)) {
+      if (is.integer(image.top)) {
+        composite.top = image.top;
+      } else {
+        throw is.invalidParameterError('top', 'integer', image.top);
+      }
+    }
+    if (is.defined(image.top) !== is.defined(image.left)) {
+      throw new Error('Expected both left and top to be set');
+    } else {
+      composite.hasOffset = is.integer(image.top) && is.integer(image.left);
+    }
+    if (is.defined(image.gravity)) {
+      if (is.integer(image.gravity) && is.inRange(image.gravity, 0, 8)) {
+        composite.gravity = image.gravity;
+      } else if (is.string(image.gravity) && is.integer(this.constructor.gravity[image.gravity])) {
+        composite.gravity = this.constructor.gravity[image.gravity];
+      } else {
+        throw is.invalidParameterError('gravity', 'valid gravity', image.gravity);
+      }
+    }
+    if (is.defined(image.premultiplied)) {
+      if (is.bool(image.premultiplied)) {
+        composite.premultiplied = image.premultiplied;
+      } else {
+        throw is.invalidParameterError('premultiplied', 'boolean', image.premultiplied);
+      }
+    }
+    return composite;
+  });
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with composite-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Sharp.prototype.composite = composite;
+  Sharp.blend = blend;
+};

lib/constructor.js

@@ -0,0 +1,423 @@
+'use strict';
+
+const util = require('util');
+const stream = require('stream');
+const is = require('./is');
+
+require('./libvips').hasVendoredLibvips();
+require('./sharp');
+
+// Use NODE_DEBUG=sharp to enable libvips warnings
+const debuglog = util.debuglog('sharp');
+
+/**
+ * Constructor factory to create an instance of `sharp`, to which further methods are chained.
+ *
+ * JPEG, PNG, WebP, 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.
+ *
+ * Implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
+ *
+ * @constructs Sharp
+ *
+ * @emits Sharp#info
+ * @emits Sharp#warning
+ *
+ * @example
+ * sharp('input.jpg')
+ *   .resize(300, 200)
+ *   .toFile('output.jpg', function(err) {
+ *     // output.jpg is a 300 pixels wide and 200 pixels high image
+ *     // containing a scaled and cropped version of input.jpg
+ *   });
+ *
+ * @example
+ * // Read image data from readableStream,
+ * // resize to 300 pixels wide,
+ * // emit an 'info' event with calculated dimensions
+ * // and finally write image data to writableStream
+ * var transformer = sharp()
+ *   .resize(300)
+ *   .on('info', function(info) {
+ *     console.log('Image height is ' + info.height);
+ *   });
+ * readableStream.pipe(transformer).pipe(writableStream);
+ *
+ * @example
+ * // Create a blank 300x200 PNG image of semi-transluent red pixels
+ * sharp({
+ *   create: {
+ *     width: 300,
+ *     height: 200,
+ *     channels: 4,
+ *     background: { r: 255, g: 0, b: 0, alpha: 0.5 }
+ *   }
+ * })
+ * .png()
+ * .toBuffer()
+ * .then( ... );
+ *
+ * @example
+ * // Convert an animated GIF to an animated WebP
+ * await sharp('in.gif', { animated: true }).toFile('out.webp');
+ *
+ * @example
+ * // Read a raw array of pixels and save it to a png
+ * const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
+ * const image = sharp(input, {
+ *   // because the input does not contain its dimensions or how many channels it has
+ *   // we need to specify it in the constructor options
+ *   raw: {
+ *     width: 2,
+ *     height: 1,
+ *     channels: 3
+ *   }
+ * });
+ * await image.toFile('my-two-pixels.png');
+ *
+ * @example
+ * // Generate RGB Gaussian noise
+ * await sharp({
+ *   create: {
+ *     width: 300,
+ *     height: 200,
+ *     channels: 3,
+ *     noise: {
+ *       type: 'gaussian',
+ *       mean: 128,
+ *       sigma: 30
+ *     }
+ *  }
+ * }).toFile('noise.png');
+ *
+ * @example
+ * // Generate an image from text
+ * await sharp({
+ *   text: {
+ *     text: 'Hello, world!',
+ *     width: 400, // max width
+ *     height: 300 // max height
+ *   }
+ * }).toFile('text_bw.png');
+ *
+ * @example
+ * // Generate an rgba image from text using pango markup and font
+ * await sharp({
+ *   text: {
+ *     text: '<span foreground="red">Red!</span><span background="cyan">blue</span>',
+ *     font: 'sans',
+ *     rgba: true,
+ *     dpi: 300
+ *   }
+ * }).toFile('text_rgba.png');
+ *
+ * @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.
+ * @param {string} [options.failOn='warning'] - level of sensitivity to invalid images, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels.
+ * @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 (JPEG, PNG, SVG, HEIF).
+ * @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.
+ * @param {number} [options.create.channels] - integral number of channels, either 3 (RGB) or 4 (RGBA).
+ * @param {string|Object} [options.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [options.create.noise] - describes a noise to be created.
+ * @param {string} [options.create.noise.type] - type of generated noise, currently only `gaussian` is supported.
+ * @param {number} [options.create.noise.mean] - mean of pixels in generated noise.
+ * @param {number} [options.create.noise.sigma] - standard deviation of pixels in generated noise.
+ * @param {Object} [options.text] - describes a new text image to be created.
+ * @param {string} [options.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+ * @param {string} [options.text.font] - font name to render with.
+ * @param {string} [options.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
+ * @param {number} [options.text.width=0] - integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
+ * @param {number} [options.text.height=0] - integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
+ * @param {string} [options.text.align='left'] - text alignment (`'left'`, `'centre'`, `'center'`, `'right'`).
+ * @param {boolean} [options.text.justify=false] - set this to true to apply justification to the text.
+ * @param {number} [options.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
+ * @param {boolean} [options.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`.
+ * @param {number} [options.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+const Sharp = function (input, options) {
+  if (arguments.length === 1 && !is.defined(input)) {
+    throw new Error('Invalid input');
+  }
+  if (!(this instanceof Sharp)) {
+    return new Sharp(input, options);
+  }
+  stream.Duplex.call(this);
+  this.options = {
+    // resize options
+    topOffsetPre: -1,
+    leftOffsetPre: -1,
+    widthPre: -1,
+    heightPre: -1,
+    topOffsetPost: -1,
+    leftOffsetPost: -1,
+    widthPost: -1,
+    heightPost: -1,
+    width: -1,
+    height: -1,
+    canvas: 'crop',
+    position: 0,
+    resizeBackground: [0, 0, 0, 255],
+    useExifOrientation: false,
+    angle: 0,
+    rotationAngle: 0,
+    rotationBackground: [0, 0, 0, 255],
+    rotateBeforePreExtract: false,
+    flip: false,
+    flop: false,
+    extendTop: 0,
+    extendBottom: 0,
+    extendLeft: 0,
+    extendRight: 0,
+    extendBackground: [0, 0, 0, 255],
+    withoutEnlargement: false,
+    withoutReduction: false,
+    affineMatrix: [],
+    affineBackground: [0, 0, 0, 255],
+    affineIdx: 0,
+    affineIdy: 0,
+    affineOdx: 0,
+    affineOdy: 0,
+    affineInterpolator: this.constructor.interpolators.bilinear,
+    kernel: 'lanczos3',
+    fastShrinkOnLoad: true,
+    // operations
+    tintA: 128,
+    tintB: 128,
+    flatten: false,
+    flattenBackground: [0, 0, 0],
+    negate: false,
+    negateAlpha: true,
+    medianSize: 0,
+    blurSigma: 0,
+    sharpenSigma: 0,
+    sharpenM1: 1,
+    sharpenM2: 2,
+    sharpenX1: 2,
+    sharpenY2: 10,
+    sharpenY3: 20,
+    threshold: 0,
+    thresholdGrayscale: true,
+    trimBackground: [],
+    trimThreshold: 0,
+    gamma: 0,
+    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: -1,
+    colourspace: 'srgb',
+    colourspaceInput: 'last',
+    composite: [],
+    // output
+    fileOut: '',
+    formatOut: 'input',
+    streamOut: false,
+    withMetadata: false,
+    withMetadataOrientation: -1,
+    withMetadataDensity: 0,
+    withMetadataIcc: '',
+    withMetadataStrs: {},
+    resolveWithObject: false,
+    // output format
+    jpegQuality: 80,
+    jpegProgressive: false,
+    jpegChromaSubsampling: '4:2:0',
+    jpegTrellisQuantisation: false,
+    jpegOvershootDeringing: false,
+    jpegOptimiseScans: false,
+    jpegOptimiseCoding: true,
+    jpegQuantisationTable: 0,
+    pngProgressive: false,
+    pngCompressionLevel: 6,
+    pngAdaptiveFiltering: false,
+    pngPalette: false,
+    pngQuality: 100,
+    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,
+    webpEffort: 4,
+    webpMinSize: false,
+    webpMixed: false,
+    gifBitdepth: 8,
+    gifEffort: 7,
+    gifDither: 1,
+    gifReoptimise: false,
+    tiffQuality: 80,
+    tiffCompression: 'jpeg',
+    tiffPredictor: 'horizontal',
+    tiffPyramid: false,
+    tiffBitdepth: 8,
+    tiffTile: false,
+    tiffTileHeight: 256,
+    tiffTileWidth: 256,
+    tiffXres: 1.0,
+    tiffYres: 1.0,
+    tiffResolutionUnit: 'inch',
+    heifQuality: 50,
+    heifLossless: false,
+    heifCompression: 'av1',
+    heifEffort: 4,
+    heifChromaSubsampling: '4:4:4',
+    rawDepth: 'uchar',
+    tileSize: 256,
+    tileOverlap: 0,
+    tileContainer: 'fs',
+    tileLayout: 'dz',
+    tileFormat: 'last',
+    tileDepth: 'last',
+    tileAngle: 0,
+    tileSkipBlanks: -1,
+    tileBackground: [255, 255, 255, 255],
+    tileCentre: false,
+    tileId: 'https://example.com/iiif',
+    tileBasename: '',
+    timeoutSeconds: 0,
+    linearA: [],
+    linearB: [],
+    // Function to notify of libvips warnings
+    debuglog: warning => {
+      this.emit('warning', warning);
+      debuglog(warning);
+    },
+    // Function to notify of queue length changes
+    queueListener: function (queueLength) {
+      Sharp.queue.emit('change', queueLength);
+    }
+  };
+  this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
+  return this;
+};
+Object.setPrototypeOf(Sharp.prototype, stream.Duplex.prototype);
+Object.setPrototypeOf(Sharp, stream.Duplex);
+
+/**
+ * Take a "snapshot" of the Sharp instance, returning a new instance.
+ * Cloned instances inherit the input of their parent instance.
+ * This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
+ *
+ * @example
+ * const pipeline = sharp().rotate();
+ * pipeline.clone().resize(800, 600).pipe(firstWritableStream);
+ * pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
+ * readableStream.pipe(pipeline);
+ * // firstWritableStream receives auto-rotated, resized readableStream
+ * // secondWritableStream receives auto-rotated, extracted region of readableStream
+ *
+ * @example
+ * // Create a pipeline that will download an image, resize it and format it to different files
+ * // Using Promises to know when the pipeline is complete
+ * const fs = require("fs");
+ * const got = require("got");
+ * const sharpStream = sharp({ failOn: 'none' });
+ *
+ * const promises = [];
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .jpeg({ quality: 100 })
+ *     .toFile("originalFile.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .jpeg({ quality: 80 })
+ *     .toFile("optimized-500.jpg")
+ * );
+ *
+ * promises.push(
+ *   sharpStream
+ *     .clone()
+ *     .resize({ width: 500 })
+ *     .webp({ quality: 80 })
+ *     .toFile("optimized-500.webp")
+ * );
+ *
+ * // https://github.com/sindresorhus/got/blob/main/documentation/3-streams.md
+ * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
+ *
+ * Promise.all(promises)
+ *   .then(res => { console.log("Done!", res); })
+ *   .catch(err => {
+ *     console.error("Error processing files, let's clean it up", err);
+ *     try {
+ *       fs.unlinkSync("originalFile.jpg");
+ *       fs.unlinkSync("optimized-500.jpg");
+ *       fs.unlinkSync("optimized-500.webp");
+ *     } catch (e) {}
+ *   });
+ *
+ * @returns {Sharp}
+ */
+function clone () {
+  // Clone existing options
+  const clone = this.constructor.call();
+  clone.options = Object.assign({}, this.options);
+  // Pass 'finish' event to clone for Stream-based input
+  if (this._isStreamInput()) {
+    this.on('finish', () => {
+      // Clone inherits input data
+      this._flattenBufferIn();
+      clone.options.bufferIn = this.options.bufferIn;
+      clone.emit('finish');
+    });
+  }
+  return clone;
+}
+Object.assign(Sharp.prototype, { clone });
+
+/**
+ * Export constructor.
+ * @private
+ */
+module.exports = Sharp;

lib/index.js

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

lib/input.js

@@ -0,0 +1,599 @@
+'use strict';
+
+const color = require('color');
+const is = require('./is');
+const sharp = require('./sharp');
+
+/**
+ * Justication alignment
+ * @member
+ * @private
+ */
+const align = {
+  left: 'low',
+  center: 'centre',
+  centre: 'centre',
+  right: 'high'
+};
+
+/**
+ * Extract input options, if any, from an object.
+ * @private
+ */
+function _inputOptionsFromObject (obj) {
+  const { raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd } = obj;
+  return [raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd].some(is.defined)
+    ? { raw, density, limitInputPixels, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd }
+    : undefined;
+}
+
+/**
+ * Create Object containing input and input-related options.
+ * @private
+ */
+function _createInputDescriptor (input, inputOptions, containerOptions) {
+  const inputDescriptor = {
+    failOn: 'warning',
+    limitInputPixels: Math.pow(0x3FFF, 2),
+    unlimited: false,
+    sequentialRead: false
+  };
+  if (is.string(input)) {
+    // filesystem
+    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.typedArray(input)) {
+    if (input.length === 0) {
+      throw Error('Input Bit Array is empty');
+    }
+    inputDescriptor.buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  } else if (is.plainObject(input) && !is.defined(inputOptions)) {
+    // Plain Object descriptor, e.g. create
+    inputOptions = input;
+    if (_inputOptionsFromObject(inputOptions)) {
+      // Stream with options
+      inputDescriptor.buffer = [];
+    }
+  } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
+    // Stream without options
+    inputDescriptor.buffer = [];
+  } else {
+    throw new Error(`Unsupported input '${input}' of type ${typeof input}${
+      is.defined(inputOptions) ? ` when also providing options of type ${typeof inputOptions}` : ''
+    }`);
+  }
+  if (is.object(inputOptions)) {
+    // Deprecated: failOnError
+    if (is.defined(inputOptions.failOnError)) {
+      if (is.bool(inputOptions.failOnError)) {
+        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
+      } else {
+        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
+      }
+    }
+    // failOn
+    if (is.defined(inputOptions.failOn)) {
+      if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
+        inputDescriptor.failOn = inputOptions.failOn;
+      } else {
+        throw is.invalidParameterError('failOn', 'one of: none, truncated, error, warning', inputOptions.failOn);
+      }
+    }
+    // Density
+    if (is.defined(inputOptions.density)) {
+      if (is.inRange(inputOptions.density, 1, 100000)) {
+        inputDescriptor.density = inputOptions.density;
+      } else {
+        throw is.invalidParameterError('density', 'number between 1 and 100000', inputOptions.density);
+      }
+    }
+    // limitInputPixels
+    if (is.defined(inputOptions.limitInputPixels)) {
+      if (is.bool(inputOptions.limitInputPixels)) {
+        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels
+          ? Math.pow(0x3FFF, 2)
+          : 0;
+      } else if (is.integer(inputOptions.limitInputPixels) && is.inRange(inputOptions.limitInputPixels, 0, Number.MAX_SAFE_INTEGER)) {
+        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
+      } else {
+        throw is.invalidParameterError('limitInputPixels', 'positive integer', 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)) {
+        inputDescriptor.sequentialRead = inputOptions.sequentialRead;
+      } else {
+        throw is.invalidParameterError('sequentialRead', 'boolean', inputOptions.sequentialRead);
+      }
+    }
+    // Raw pixel input
+    if (is.defined(inputOptions.raw)) {
+      if (
+        is.object(inputOptions.raw) &&
+        is.integer(inputOptions.raw.width) && inputOptions.raw.width > 0 &&
+        is.integer(inputOptions.raw.height) && inputOptions.raw.height > 0 &&
+        is.integer(inputOptions.raw.channels) && is.inRange(inputOptions.raw.channels, 1, 4)
+      ) {
+        inputDescriptor.rawWidth = inputOptions.raw.width;
+        inputDescriptor.rawHeight = inputOptions.raw.height;
+        inputDescriptor.rawChannels = inputOptions.raw.channels;
+        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');
+      }
+    }
+    // Multi-page input (GIF, TIFF, PDF)
+    if (is.defined(inputOptions.animated)) {
+      if (is.bool(inputOptions.animated)) {
+        inputDescriptor.pages = inputOptions.animated ? -1 : 1;
+      } else {
+        throw is.invalidParameterError('animated', 'boolean', inputOptions.animated);
+      }
+    }
+    if (is.defined(inputOptions.pages)) {
+      if (is.integer(inputOptions.pages) && is.inRange(inputOptions.pages, -1, 100000)) {
+        inputDescriptor.pages = inputOptions.pages;
+      } else {
+        throw is.invalidParameterError('pages', 'integer between -1 and 100000', inputOptions.pages);
+      }
+    }
+    if (is.defined(inputOptions.page)) {
+      if (is.integer(inputOptions.page) && is.inRange(inputOptions.page, 0, 100000)) {
+        inputDescriptor.page = inputOptions.page;
+      } else {
+        throw is.invalidParameterError('page', 'integer between 0 and 100000', inputOptions.page);
+      }
+    }
+    // Multi-level input (OpenSlide)
+    if (is.defined(inputOptions.level)) {
+      if (is.integer(inputOptions.level) && is.inRange(inputOptions.level, 0, 256)) {
+        inputDescriptor.level = inputOptions.level;
+      } else {
+        throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
+      }
+    }
+    // Sub Image File Directory (TIFF)
+    if (is.defined(inputOptions.subifd)) {
+      if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
+        inputDescriptor.subifd = inputOptions.subifd;
+      } else {
+        throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
+      }
+    }
+    // Create new image
+    if (is.defined(inputOptions.create)) {
+      if (
+        is.object(inputOptions.create) &&
+        is.integer(inputOptions.create.width) && inputOptions.create.width > 0 &&
+        is.integer(inputOptions.create.height) && inputOptions.create.height > 0 &&
+        is.integer(inputOptions.create.channels)
+      ) {
+        inputDescriptor.createWidth = inputOptions.create.width;
+        inputDescriptor.createHeight = inputOptions.create.height;
+        inputDescriptor.createChannels = inputOptions.create.channels;
+        // Noise
+        if (is.defined(inputOptions.create.noise)) {
+          if (!is.object(inputOptions.create.noise)) {
+            throw new Error('Expected noise to be an object');
+          }
+          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+            throw new Error('Only gaussian noise is supported at the moment');
+          }
+          if (!is.inRange(inputOptions.create.channels, 1, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
+          }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
+          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+          } else {
+            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          }
+          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+          } else {
+            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          }
+        } else if (is.defined(inputOptions.create.background)) {
+          if (!is.inRange(inputOptions.create.channels, 3, 4)) {
+            throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
+          }
+          const background = color(inputOptions.create.background);
+          inputDescriptor.createBackground = [
+            background.red(),
+            background.green(),
+            background.blue(),
+            Math.round(background.alpha() * 255)
+          ];
+        } else {
+          throw new Error('Expected valid noise or background to create a new input image');
+        }
+        delete inputDescriptor.buffer;
+      } else {
+        throw new Error('Expected valid width, height and channels to create a new input image');
+      }
+    }
+    // Create a new image with text
+    if (is.defined(inputOptions.text)) {
+      if (is.object(inputOptions.text) && is.string(inputOptions.text.text)) {
+        inputDescriptor.textValue = inputOptions.text.text;
+        if (is.defined(inputOptions.text.height) && is.defined(inputOptions.text.dpi)) {
+          throw new Error('Expected only one of dpi or height');
+        }
+        if (is.defined(inputOptions.text.font)) {
+          if (is.string(inputOptions.text.font)) {
+            inputDescriptor.textFont = inputOptions.text.font;
+          } else {
+            throw is.invalidParameterError('text.font', 'string', inputOptions.text.font);
+          }
+        }
+        if (is.defined(inputOptions.text.fontfile)) {
+          if (is.string(inputOptions.text.fontfile)) {
+            inputDescriptor.textFontfile = inputOptions.text.fontfile;
+          } else {
+            throw is.invalidParameterError('text.fontfile', 'string', inputOptions.text.fontfile);
+          }
+        }
+        if (is.defined(inputOptions.text.width)) {
+          if (is.number(inputOptions.text.width)) {
+            inputDescriptor.textWidth = inputOptions.text.width;
+          } else {
+            throw is.invalidParameterError('text.textWidth', 'number', inputOptions.text.width);
+          }
+        }
+        if (is.defined(inputOptions.text.height)) {
+          if (is.number(inputOptions.text.height)) {
+            inputDescriptor.textHeight = inputOptions.text.height;
+          } else {
+            throw is.invalidParameterError('text.height', 'number', inputOptions.text.height);
+          }
+        }
+        if (is.defined(inputOptions.text.align)) {
+          if (is.string(inputOptions.text.align) && is.string(this.constructor.align[inputOptions.text.align])) {
+            inputDescriptor.textAlign = this.constructor.align[inputOptions.text.align];
+          } else {
+            throw is.invalidParameterError('text.align', 'valid alignment', inputOptions.text.align);
+          }
+        }
+        if (is.defined(inputOptions.text.justify)) {
+          if (is.bool(inputOptions.text.justify)) {
+            inputDescriptor.textJustify = inputOptions.text.justify;
+          } else {
+            throw is.invalidParameterError('text.justify', 'boolean', inputOptions.text.justify);
+          }
+        }
+        if (is.defined(inputOptions.text.dpi)) {
+          if (is.number(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 100000)) {
+            inputDescriptor.textDpi = inputOptions.text.dpi;
+          } else {
+            throw is.invalidParameterError('text.dpi', 'number between 1 and 100000', inputOptions.text.dpi);
+          }
+        }
+        if (is.defined(inputOptions.text.rgba)) {
+          if (is.bool(inputOptions.text.rgba)) {
+            inputDescriptor.textRgba = inputOptions.text.rgba;
+          } else {
+            throw is.invalidParameterError('text.rgba', 'bool', inputOptions.text.rgba);
+          }
+        }
+        if (is.defined(inputOptions.text.spacing)) {
+          if (is.number(inputOptions.text.spacing)) {
+            inputDescriptor.textSpacing = inputOptions.text.spacing;
+          } else {
+            throw is.invalidParameterError('text.spacing', 'number', inputOptions.text.spacing);
+          }
+        }
+        delete inputDescriptor.buffer;
+      } else {
+        throw new Error('Expected a valid string to create an image with text.');
+      }
+    }
+  } else if (is.defined(inputOptions)) {
+    throw new Error('Invalid input options ' + inputOptions);
+  }
+  return inputDescriptor;
+}
+
+/**
+ * Handle incoming Buffer chunk on Writable Stream.
+ * @private
+ * @param {Buffer} chunk
+ * @param {string} encoding - unused
+ * @param {Function} callback
+ */
+function _write (chunk, encoding, callback) {
+  /* istanbul ignore else */
+  if (Array.isArray(this.options.input.buffer)) {
+    /* istanbul ignore else */
+    if (is.buffer(chunk)) {
+      if (this.options.input.buffer.length === 0) {
+        this.on('finish', () => {
+          this.streamInFinished = true;
+        });
+      }
+      this.options.input.buffer.push(chunk);
+      callback();
+    } else {
+      callback(new Error('Non-Buffer data on Writable Stream'));
+    }
+  } else {
+    callback(new Error('Unexpected data on Writable Stream'));
+  }
+}
+
+/**
+ * Flattens the array of chunks accumulated in input.buffer.
+ * @private
+ */
+function _flattenBufferIn () {
+  if (this._isStreamInput()) {
+    this.options.input.buffer = Buffer.concat(this.options.input.buffer);
+  }
+}
+
+/**
+ * Are we expecting Stream-based input?
+ * @private
+ * @returns {boolean}
+ */
+function _isStreamInput () {
+  return Array.isArray(this.options.input.buffer);
+}
+
+/**
+ * Fast access to (uncached) image metadata without decoding any compressed 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.
+ *
+ * Dimensions in the response will respect the `page` and `pages` properties of the
+ * {@link /api-constructor#parameters|constructor parameters}.
+ *
+ * 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, see example below)
+ * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://www.libvips.org/API/current/VipsImage.html#VipsInterpretation)
+ * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://www.libvips.org/API/current/VipsImage.html#VipsBandFormat)
+ * - `density`: Number of pixels per inch (DPI), if present
+ * - `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
+ * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+ * - `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
+ * - `pageHeight`: Number of pixels high each page in a multi-page image will be.
+ * - `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
+ * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
+ * - `pagePrimary`: Number of the primary page in a HEIF image
+ * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
+ * - `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](https://www.npmjs.com/package/icc) profile data, if present
+ * - `iptc`: Buffer containing raw IPTC data, if present
+ * - `xmp`: Buffer containing raw XMP data, if present
+ * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
+ *
+ * @example
+ * const metadata = await sharp(input).metadata();
+ *
+ * @example
+ * const image = sharp(inputJpg);
+ * image
+ *   .metadata()
+ *   .then(function(metadata) {
+ *     return image
+ *       .resize(Math.round(metadata.width / 2))
+ *       .webp()
+ *       .toBuffer();
+ *   })
+ *   .then(function(data) {
+ *     // data contains a WebP image half the width and height of the original JPEG
+ *   });
+ *
+ * @example
+ * // Based on EXIF rotation metadata, get the right-side-up width and height:
+ *
+ * const size = getNormalSize(await sharp(input).metadata());
+ *
+ * function getNormalSize({ width, height, orientation }) {
+ *   return (orientation || 0) >= 5
+ *     ? { width: height, height: width }
+ *     : { width, height };
+ * }
+ *
+ * @param {Function} [callback] - called with the arguments `(err, metadata)`
+ * @returns {Promise<Object>|Sharp}
+ */
+function metadata (callback) {
+  if (is.fn(callback)) {
+    if (this._isStreamInput()) {
+      this.on('finish', () => {
+        this._flattenBufferIn();
+        sharp.metadata(this.options, callback);
+      });
+    } else {
+      sharp.metadata(this.options, callback);
+    }
+    return this;
+  } else {
+    if (this._isStreamInput()) {
+      return new Promise((resolve, reject) => {
+        this.on('finish', () => {
+          this._flattenBufferIn();
+          sharp.metadata(this.options, (err, metadata) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(metadata);
+            }
+          });
+        });
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        sharp.metadata(this.options, (err, metadata) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(metadata);
+          }
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Access to pixel-derived image statistics for every channel in the image.
+ * A `Promise` is returned when `callback` is not provided.
+ *
+ * - `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
+ *     - `min` (minimum value in the channel)
+ *     - `max` (maximum value in the channel)
+ *     - `sum` (sum of all values in a channel)
+ *     - `squaresSum` (sum of squared values in a channel)
+ *     - `mean` (mean of the values in a channel)
+ *     - `stdev` (standard deviation for the values in a channel)
+ *     - `minX` (x-coordinate of one of the pixel where the minimum lies)
+ *     - `minY` (y-coordinate of one of the pixel where the minimum lies)
+ *     - `maxX` (x-coordinate of one of the pixel where the maximum lies)
+ *     - `maxY` (y-coordinate of one of the pixel where the maximum lies)
+ * - `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
+ * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any.
+ * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any.
+ * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram.
+ *
+ * **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
+ *   .stats()
+ *   .then(function(stats) {
+ *      // stats contains the channel-wise statistics array and the isOpaque value
+ *   });
+ *
+ * @example
+ * const { entropy, sharpness, dominant } = await sharp(input).stats();
+ * const { r, g, b } = dominant;
+ *
+ * @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>}
+ */
+function stats (callback) {
+  if (is.fn(callback)) {
+    if (this._isStreamInput()) {
+      this.on('finish', () => {
+        this._flattenBufferIn();
+        sharp.stats(this.options, callback);
+      });
+    } else {
+      sharp.stats(this.options, callback);
+    }
+    return this;
+  } else {
+    if (this._isStreamInput()) {
+      return new Promise((resolve, reject) => {
+        this.on('finish', function () {
+          this._flattenBufferIn();
+          sharp.stats(this.options, (err, stats) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(stats);
+            }
+          });
+        });
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        sharp.stats(this.options, (err, stats) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(stats);
+          }
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Decorate the Sharp prototype with input-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Object.assign(Sharp.prototype, {
+    // Private
+    _inputOptionsFromObject,
+    _createInputDescriptor,
+    _write,
+    _flattenBufferIn,
+    _isStreamInput,
+    // Public
+    metadata,
+    stats
+  });
+  // Class attributes
+  Sharp.align = align;
+};

lib/is.js

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

lib/libvips.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const spawnSync = require('child_process').spawnSync;
+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 */
+  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, { recursive: true });
+  } catch (err) {
+    /* istanbul ignore next */
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+  }
+};
+
+const cachePath = function () {
+  const npmCachePath = env.npm_config_cache || /* istanbul ignore next */
+    (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(os.homedir(), '.npm'));
+  mkdirSync(npmCachePath);
+  const libvipsCachePath = path.join(npmCachePath, '_libvips');
+  mkdirSync(libvipsCachePath);
+  return libvipsCachePath;
+};
+
+const 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: Installation error: ${item.message}`);
+  } else {
+    console.log(`sharp: ${item}`);
+  }
+};
+
+const isRosetta = function () {
+  /* istanbul ignore next */
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
+    return (translated || '').trim() === 'sysctl.proc_translated: 1';
+  }
+  return false;
+};
+
+const globalLibvipsVersion = function () {
+  if (process.platform !== 'win32') {
+    const globalLibvipsVersion = spawnSync('pkg-config --modversion vips-cpp', {
+      ...spawnSyncOptions,
+      env: {
+        ...env,
+        PKG_CONFIG_PATH: pkgConfigPath()
+      }
+    }).stdout;
+    /* istanbul ignore next */
+    return (globalLibvipsVersion || '').trim();
+  } else {
+    return '';
+  }
+};
+
+const hasVendoredLibvips = function () {
+  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 });
+};
+
+/* istanbul ignore next */
+const pkgConfigPath = function () {
+  if (process.platform !== 'win32') {
+    const brewPkgConfigPath = spawnSync(
+      'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
+      spawnSyncOptions
+    ).stdout || '';
+    return [
+      brewPkgConfigPath.trim(),
+      env.PKG_CONFIG_PATH,
+      '/usr/local/lib/pkgconfig',
+      '/usr/lib/pkgconfig',
+      '/usr/local/libdata/pkgconfig',
+      '/usr/libdata/pkgconfig'
+    ].filter(Boolean).join(':');
+  } else {
+    return '';
+  }
+};
+
+const useGlobalLibvips = function () {
+  if (Boolean(env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+    return false;
+  }
+  /* istanbul ignore next */
+  if (isRosetta()) {
+    return false;
+  }
+  const globalVipsVersion = globalLibvipsVersion();
+  return !!globalVipsVersion && /* istanbul ignore next */
+    semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
+};
+
+module.exports = {
+  minimumLibvipsVersion,
+  minimumLibvipsVersionLabelled,
+  cachePath,
+  integrity,
+  log,
+  globalLibvipsVersion,
+  hasVendoredLibvips,
+  removeVendoredLibvips,
+  pkgConfigPath,
+  useGlobalLibvips,
+  mkdirSync
+};

lib/operation.js

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

lib/platform.js

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

lib/resize.js

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

lib/sharp.js

@@ -0,0 +1,35 @@
+'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('-');
+    if (platform === 'linux' && /Module did not self-register/.test(err.message)) {
+      help.push('- Using worker threads? See https://sharp.pixelplumbing.com/install#worker-threads');
+    }
+    help.push(
+      '- Install with verbose logging and look for errors: "npm install --ignore-scripts=false --foreground-scripts --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' || /symbol/.test(err.message)) {
+    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

@@ -0,0 +1,215 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const events = require('events');
+const detectLibc = require('detect-libc');
+
+const is = require('./is');
+const platformAndArch = require('./platform')();
+const sharp = require('./sharp');
+
+/**
+ * An Object containing nested boolean values representing the available input and output formats/methods.
+ * @member
+ * @example
+ * console.log(sharp.format);
+ * @returns {Object}
+ */
+const format = sharp.format();
+format.heif.output.alias = ['avif', 'heic'];
+format.jpeg.output.alias = ['jpe', 'jpg'];
+format.tiff.output.alias = ['tif'];
+format.jp2k.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
+
+/**
+ * An Object containing the available interpolators and their proper values
+ * @readonly
+ * @enum {string}
+ */
+const interpolators = {
+  /** [Nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation). Suitable for image enlargement only. */
+  nearest: 'nearest',
+  /** [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation). Faster than bicubic but with less smooth results. */
+  bilinear: 'bilinear',
+  /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
+  bicubic: 'bicubic',
+  /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+  locallyBoundedBicubic: 'lbb',
+  /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
+  nohalo: 'nohalo',
+  /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+
+/**
+ * An Object containing the version numbers of libvips and its dependencies.
+ * @member
+ * @example
+ * console.log(sharp.versions);
+ */
+let versions = {
+  vips: sharp.libvipsVersion()
+};
+try {
+  versions = require(`../vendor/${versions.vips}/${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.
+ * Existing entries in the cache will be trimmed after any change in limits.
+ * This method always returns cache statistics,
+ * useful for determining how much working memory is required for a particular task.
+ *
+ * @example
+ * const stats = sharp.cache();
+ * @example
+ * sharp.cache( { items: 200 } );
+ * sharp.cache( { files: 0 } );
+ * sharp.cache(false);
+ *
+ * @param {Object|boolean} [options=true] - Object with the following attributes, or boolean where true uses default cache settings and false removes all caching
+ * @param {number} [options.memory=50] - is the maximum memory in MB to use for this cache
+ * @param {number} [options.files=20] - is the maximum number of files to hold open
+ * @param {number} [options.items=100] - is the maximum number of operations to cache
+ * @returns {Object}
+ */
+function cache (options) {
+  if (is.bool(options)) {
+    if (options) {
+      // Default cache settings of 50MB, 20 files, 100 items
+      return sharp.cache(50, 20, 100);
+    } else {
+      return sharp.cache(0, 0, 0);
+    }
+  } else if (is.object(options)) {
+    return sharp.cache(options.memory, options.files, options.items);
+  } else {
+    return sharp.cache();
+  }
+}
+cache(true);
+
+/**
+ * Gets or, when a concurrency is provided, sets
+ * the maximum number of threads _libvips_ should use to process _each image_.
+ * These are from a thread pool managed by glib,
+ * which helps avoid the overhead of creating new threads.
+ *
+ * This method always returns the current concurrency.
+ *
+ * The default value is the number of CPU cores,
+ * except when using glibc-based Linux without jemalloc,
+ * where the default is `1` to help reduce memory fragmentation.
+ *
+ * A value of `0` will reset this to the number of CPU cores.
+ *
+ * Some image format libraries spawn additional threads,
+ * e.g. libaom manages its own 4 threads when encoding AVIF images,
+ * and these are independent of the value set here.
+ *
+ * The maximum number of images that sharp can process in parallel
+ * is controlled by libuv's `UV_THREADPOOL_SIZE` environment variable,
+ * which defaults to 4.
+ *
+ * https://nodejs.org/api/cli.html#uv_threadpool_sizesize
+ *
+ * For example, by default, a machine with 8 CPU cores will process
+ * 4 images in parallel and use up to 8 threads per image,
+ * so there will be up to 32 concurrent threads.
+ *
+ * @example
+ * const threads = sharp.concurrency(); // 4
+ * sharp.concurrency(2); // 2
+ * sharp.concurrency(0); // 4
+ *
+ * @param {number} [concurrency]
+ * @returns {number} concurrency
+ */
+function concurrency (concurrency) {
+  return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
+}
+/* istanbul ignore next */
+if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+  // Reduce default concurrency to 1 when using glibc memory allocator
+  sharp.concurrency(1);
+}
+
+/**
+ * An EventEmitter that emits a `change` event when a task is either:
+ * - queued, waiting for _libuv_ to provide a worker thread
+ * - complete
+ * @member
+ * @example
+ * sharp.queue.on('change', function(queueLength) {
+ *   console.log('Queue contains ' + queueLength + ' task(s)');
+ * });
+ */
+const queue = new events.EventEmitter();
+
+/**
+ * Provides access to internal task counters.
+ * - queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
+ * - process is the number of resize tasks currently being processed.
+ *
+ * @example
+ * const counters = sharp.counters(); // { queue: 2, process: 4 }
+ *
+ * @returns {Object}
+ */
+function counters () {
+  return sharp.counters();
+}
+
+/**
+ * Get and set use of SIMD vector unit instructions.
+ * Requires libvips to have been compiled with liborc support.
+ *
+ * Improves the performance of `resize`, `blur` and `sharpen` operations
+ * by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
+ *
+ * @example
+ * const simd = sharp.simd();
+ * // simd is `true` if the runtime use of liborc is currently enabled
+ * @example
+ * const simd = sharp.simd(false);
+ * // prevent libvips from using liborc at runtime
+ *
+ * @param {boolean} [simd=true]
+ * @returns {boolean}
+ */
+function simd (simd) {
+  return sharp.simd(is.bool(simd) ? simd : null);
+}
+simd(true);
+
+/**
+ * Decorate the Sharp class with utility-related functions.
+ * @private
+ */
+module.exports = function (Sharp) {
+  Sharp.cache = cache;
+  Sharp.concurrency = concurrency;
+  Sharp.counters = counters;
+  Sharp.simd = simd;
+  Sharp.format = format;
+  Sharp.interpolators = interpolators;
+  Sharp.versions = versions;
+  Sharp.vendor = vendor;
+  Sharp.queue = queue;
+};

mkdocs.yml

@@ -1,17 +0,0 @@
-site_name: sharp
-site_url: http://sharp.dimens.io/
-repo_url: https://github.com/lovell/sharp
-site_description: The fastest Node.js module for resizing JPEG, PNG, WebP and TIFF images. Uses the libvips library.
-copyright: <a href="https://dimens.io/">dimens.io</a>
-google_analytics: ['UA-13034748-12', 'sharp.dimens.io']
-theme: readthedocs
-markdown_extensions:
-  - toc:
-      permalink: True
-dev_addr: 0.0.0.0:10101
-pages:
-  - Home: index.md
-  - Installation: install.md
-  - API: api.md
-  - Performance: performance.md
-  - Changelog: changelog.md

package.json

@@ -1,7 +1,9 @@
 {
   "name": "sharp",
-  "version": "0.12.2",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
+  "version": "0.31.1",
   "author": "Lovell Fuller <npm@lovell.info>",
+  "homepage": "https://github.com/lovell/sharp",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
     "Jonathan Ong <jonathanrichardong@gmail.com>",
@@ -18,18 +20,92 @@
     "Alaric Holloway <alaric.holloway@gmail.com>",
     "Bernhard K. Weisshuhn <bkw@codingforce.com>",
     "Chris Riley <criley@primedia.com>",
-    "David Carley <dacarley@gmail.com>"
+    "David Carley <dacarley@gmail.com>",
+    "John Tobin <john@limelightmobileinc.com>",
+    "Kenton Gray <kentongray@gmail.com>",
+    "Felix Bünemann <Felix.Buenemann@gmail.com>",
+    "Samy Al Zahrani <samyalzahrany@gmail.com>",
+    "Chintan Thakkar <lemnisk8@gmail.com>",
+    "F. Orlando Galashan <frulo@gmx.de>",
+    "Kleis Auke Wolthuizen <info@kleisauke.nl>",
+    "Matt Hirsch <mhirsch@media.mit.edu>",
+    "Matthias Thoemmes <thoemmes@gmail.com>",
+    "Patrick Paskaris <patrick@paskaris.gr>",
+    "Jérémy Lal <kapouer@melix.org>",
+    "Rahul Nanwani <r.nanwani@gmail.com>",
+    "Alice Monday <alice0meta@gmail.com>",
+    "Kristo Jorgenson <kristo.jorgenson@gmail.com>",
+    "YvesBos <yves_bos@outlook.com>",
+    "Guy Maliar <guy@tailorbrands.com>",
+    "Nicolas Coden <nicolas@ncoden.fr>",
+    "Matt Parrish <matt.r.parrish@gmail.com>",
+    "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+    "Matthew McEachen <matthew+github@mceachen.org>",
+    "Jarda Kotěšovec <jarda.kotesovec@gmail.com>",
+    "Kenric D'Souza <kenric.dsouza@gmail.com>",
+    "Oleh Aleinyk <oleg.aleynik@gmail.com>",
+    "Marcel Bretschneider <marcel.bretschneider@gmail.com>",
+    "Andrea Bianco <andrea.bianco@unibas.ch>",
+    "Rik Heywood <rik@rik.org>",
+    "Thomas Parisot <hi@oncletom.io>",
+    "Nathan Graves <nathanrgraves+github@gmail.com>",
+    "Tom Lokhorst <tom@lokhorst.eu>",
+    "Espen Hovlandsdal <espen@hovlandsdal.com>",
+    "Sylvain Dumont <sylvain.dumont35@gmail.com>",
+    "Alun Davies <alun.owain.davies@googlemail.com>",
+    "Aidan Hoolachan <ajhoolachan21@gmail.com>",
+    "Axel Eirola <axel.eirola@iki.fi>",
+    "Freezy <freezy@xbmc.org>",
+    "Daiz <taneli.vatanen@gmail.com>",
+    "Julian Aubourg <j@ubourg.net>",
+    "Keith Belovay <keith@picthrive.com>",
+    "Michael B. Klein <mbklein@gmail.com>",
+    "Jordan Prudhomme <jordan@raboland.fr>",
+    "Ilya Ovdin <iovdin@gmail.com>",
+    "Andargor <andargor@yahoo.com>",
+    "Paul Neave <paul.neave@gmail.com>",
+    "Brendan Kennedy <brenwken@gmail.com>",
+    "Brychan Bennett-Odlum <git@brychan.io>",
+    "Edward Silverton <e.silverton@gmail.com>",
+    "Roman Malieiev <aromaleev@gmail.com>",
+    "Tomas Szabo <tomas.szabo@deftomat.com>",
+    "Robert O'Rourke <robert@o-rourke.org>",
+    "Guillermo Alfonso Varela Chouciño <guillevch@gmail.com>",
+    "Christian Flintrup <chr@gigahost.dk>",
+    "Manan Jadhav <manan@motionden.com>",
+    "Leon Radley <leon@radley.se>",
+    "alza54 <alza54@thiocod.in>",
+    "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>",
+    "Brodan <christopher.hranj@gmail.com",
+    "Ankur Parihar <ankur.github@gmail.com>",
+    "Brahim Ait elhaj <brahima@gmail.com>",
+    "Mart Jansink <m.jansink@gmail.com>"
   ],
-  "description": "High performance Node.js module to resize JPEG, PNG, WebP and TIFF images using the libvips library",
   "scripts": {
-    "clean": "rm -rf node_modules/ build/ include/ lib/ coverage/ test/fixtures/output.*",
-    "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=30000 ./test/unit/*.js",
-    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js",
+    "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": "npm run test-lint && npm run test-unit && npm run test-licensing",
+    "test-lint": "semistandard && cpplint",
+    "test-unit": "nyc --reporter=lcov --reporter=text --check-coverage --branches=100 mocha --slow=1000 --timeout=20000 ./test/unit/*.js",
+    "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-leak": "./test/leak/leak.sh",
-    "test-packaging": "./packaging/test.sh",
-    "test-clean": "rm -rf coverage/ test/fixtures/output.* && npm install && npm test"
+    "docs-build": "documentation lint lib && node docs/build && node docs/search-index/build",
+    "docs-serve": "cd docs && npx serve",
+    "docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
   },
-  "main": "index.js",
+  "main": "lib/index.js",
+  "files": [
+    "binding.gyp",
+    "install/**",
+    "lib/**",
+    "src/**"
+  ],
   "repository": {
     "type": "git",
     "url": "git://github.com/lovell/sharp"
@@ -38,39 +114,84 @@
     "jpeg",
     "png",
     "webp",
+    "avif",
     "tiff",
+    "gif",
+    "svg",
+    "jp2",
     "dzi",
+    "image",
     "resize",
     "thumbnail",
     "crop",
+    "embed",
     "libvips",
     "vips"
   ],
   "dependencies": {
-    "bluebird": "^3.1.1",
-    "color": "^0.11.1",
-    "nan": "^2.2.0",
-    "semver": "^5.1.0",
-    "request": "^2.67.0",
-    "tar": "^2.2.1"
+    "color": "^4.2.3",
+    "detect-libc": "^2.0.1",
+    "node-addon-api": "^5.0.0",
+    "prebuild-install": "^7.1.1",
+    "semver": "^7.3.7",
+    "simple-get": "^4.0.1",
+    "tar-fs": "^2.1.1",
+    "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^1.5.2",
-    "coveralls": "^2.11.6",
-    "exif-reader": "^1.0.0",
-    "icc": "^0.0.2",
-    "istanbul": "^0.4.2",
-    "mocha": "^2.3.4",
-    "mocha-jshint": "^2.2.6",
-    "node-cpplint": "^0.4.0",
-    "rimraf": "^2.5.0",
-    "bufferutil": "^1.2.1"
+    "async": "^3.2.4",
+    "cc": "^3.0.1",
+    "documentation": "^14.0.0",
+    "exif-reader": "^1.0.3",
+    "extract-zip": "^2.0.1",
+    "icc": "^2.0.0",
+    "license-checker": "^25.0.1",
+    "mocha": "^10.0.0",
+    "mock-fs": "^5.1.4",
+    "nyc": "^15.1.0",
+    "prebuild": "^11.0.4",
+    "rimraf": "^3.0.2",
+    "semistandard": "^16.0.1"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.2.0"
+    "libvips": "8.13.2",
+    "integrity": {
+      "darwin-arm64v8": "sha512-4tsE/HMQDT9srV/ovSJlr7IxKnhvH9qpArCAf5Xpb/uNcAiT7BcZ+HYwX2lbf3UY8REB1TR4ThEL/lmPnzMUHw==",
+      "darwin-x64": "sha512-D4ZSvlgLpf+KzKB2OD+K8NWl0JKzzIbvWwIjjwBycIHTMkaiams3Kp/AQ/bKudqof02Ks6LtP0X4XWvCaoRoUA==",
+      "linux-arm64v8": "sha512-9ZvUM2NBluhoeUz9X7/zJ48xJ5d7KzI1cO6lsiv4HKo5fOYw/vEY28XodFJzhyfu9NuKxh3Hs9FtoQGNvvAFkw==",
+      "linux-armv6": "sha512-vu0R8DF0k7KseU62fzrJadHNk5oeJriFLVn3KxCKEfV+Wkj7rX4lQhiPmOuD7/wRcUY+GGdoZ52vysDwMQhfzA==",
+      "linux-armv7": "sha512-UdfhJTjGFgrwc3Kaos5G1ZAK2+t/16Prtnl6FAT+m7cG5EXzYAqzgvk4qtakAH7UTnVe8MUgOfbTLt0YiRpfsg==",
+      "linux-x64": "sha512-sv92VpPyN+3oBv0vi4wDjx51demGdtyhEjd+vDfC3h8S/RSuIUE9Pt/+dBFuf+iv9tRdIq9hH9vzAvsLVy6NYg==",
+      "linuxmusl-arm64v8": "sha512-TjhK/wHAS/m55l46T8PZ0qvlK+PKYFZGTQfh+c9aG8/z1v/VtG7TQOLNmPWfg0SFDTkXV7YqnJCqvgYLmJPZUg==",
+      "linuxmusl-x64": "sha512-/su96pn/H9+lDdnlM1xB2whWEoeEDJICFp/RNRJb0+bJPJhnL/IDVIhF4VnVNBq/9AlldBWii3hqMq5rY2eEAA==",
+      "win32-arm64v8": "sha512-UnSmwCcx3F5u4UOXyrdwTdYsuMK/RtQYc+1y+QxqIkBHiSL7dOlTIH/vKOSQvSaDQTPqxVLFt3wkMN1U7LZwyg==",
+      "win32-ia32": "sha512-KH/H6vpx5lJ6NEzLQmwxU/QnDg8p1Jxd+WKaPiyWmXq/HpwyKrZhi3WDoyKD4fLwnlfhAXEfVLZbUbhX21pDpQ==",
+      "win32-x64": "sha512-Xim5F21pqx7MuVQViaQNhSz24zWIiKHC9bm4KCdi7q/ytbvdMhm6bzWDI/mvFGNjI62NRB2SBkTTaqwJvM/pUg=="
+    },
+    "runtime": "napi",
+    "target": 7
   },
   "engines": {
-    "node": ">=0.10"
+    "node": ">=14.15.0"
+  },
+  "funding": {
+    "url": "https://opencollective.com/libvips"
+  },
+  "binary": {
+    "napi_versions": [
+      7
+    ]
+  },
+  "semistandard": {
+    "env": [
+      "mocha"
+    ]
+  },
+  "cc": {
+    "linelength": "120",
+    "filter": [
+      "build/include"
+    ]
   }
 }

packaging/arm-build.sh

@@ -1,34 +0,0 @@
-#!/bin/sh
-
-if [ $# -lt 1 ]; then
-  echo "Usage: $0 IP"
-  echo "Build libvips for ARM using Docker, where IP is"
-  echo "the address of a Raspberry Pi running HypriotOS"
-  exit 1
-fi
-IP="$1"
-
-echo "Verifying connectivity to $IP"
-if ! ping -c 1 $IP; then
-  echo "Could not connect to $IP"
-  exit 1
-fi
-
-if ! type sshpass >/dev/null; then
-  echo "Please install sshpass"
-  exit 1
-fi
-
-export SSHPASS=hypriot
-
-echo "Copying arm/Dockerfile and arm/build.sh to device"
-sshpass -e scp -o PreferredAuthentications=password -r arm root@${IP}:/root
-
-echo "Building Raspbian-based container"
-sshpass -e ssh -o PreferredAuthentications=password -t root@${IP} "docker build -t vips-dev-arm arm"
-
-echo "Running arm/build.sh within container"
-sshpass -e ssh -o PreferredAuthentications=password -t root@${IP} "docker run -i -t --rm -v \${PWD}/arm:/arm vips-dev-arm sh -c 'cd /arm && ./build.sh' | tee arm/build.log"
-
-echo "Copying resultant tar.gz file from device"
-sshpass -e scp -o PreferredAuthentications=password root@${IP}:/root/arm/*.tar.gz .

packaging/arm-test.sh

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

packaging/arm/Dockerfile

@@ -1,5 +0,0 @@
-FROM resin/rpi-raspbian:jessie
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-# Build dependencies
-RUN apt-get update && apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo curl

packaging/arm/build.sh

@@ -1,135 +0,0 @@
-#!/bin/sh
-
-# To be run inside a Raspbian container
-
-# Working directories
-DEPS=/deps
-TARGET=/target
-mkdir ${DEPS}
-mkdir ${TARGET}
-
-# Common build paths and flags
-export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig"
-export PATH="${PATH}:${TARGET}/bin"
-export CPPFLAGS="-I${TARGET}/include"
-export LDFLAGS="-L${TARGET}/lib"
-
-# Dependency version numbers
-VERSION_ZLIB=1.2.8
-VERSION_FFI=3.2.1
-VERSION_GLIB=2.46.2
-VERSION_XML2=2.9.3
-VERSION_GSF=1.14.34
-VERSION_EXIF=0.6.21
-VERSION_JPEG=1.4.2
-VERSION_PNG16=1.6.20
-VERSION_LCMS2=2.7
-VERSION_WEBP=0.5.0
-VERSION_TIFF=4.0.6
-VERSION_MAGICK=6.9.2-10
-VERSION_ORC=0.4.24
-VERSION_VIPS=8.2.0
-
-mkdir ${DEPS}/zlib
-curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
-cd ${DEPS}/zlib
-./configure --prefix=${TARGET} && make install
-rm ${TARGET}/lib/libz.a
-
-mkdir ${DEPS}/ffi
-curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
-cd ${DEPS}/ffi
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
-
-mkdir ${DEPS}/glib
-curl -Ls http://ftp.gnome.org/pub/gnome/sources/glib/2.46/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
-cd ${DEPS}/glib
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/xml2
-curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
-cd ${DEPS}/xml2
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-python --with-zlib=${TARGET} && make install-strip
-
-mkdir ${DEPS}/gsf
-curl -Ls http://ftp.gnome.org/pub/GNOME/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
-cd ${DEPS}/gsf
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/exif
-curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
-cd ${DEPS}/exif
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/jpeg
-curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
-cd ${DEPS}/jpeg
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
-
-mkdir ${DEPS}/png16
-curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
-cd ${DEPS}/png16
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/lcms2
-curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
-cd ${DEPS}/lcms2
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/webp
-curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
-cd ${DEPS}/webp
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/tiff
-curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz /deps/tiff.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
-cd ${DEPS}/tiff
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-rm ${TARGET}/lib/libtiffxx*
-
-mkdir ${DEPS}/magick
-curl -Ls http://www.imagemagick.org/download/releases/ImageMagick-${VERSION_MAGICK}.tar.xz | tar xJC ${DEPS}/magick --strip-components=1
-cd ${DEPS}/magick
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
-mkdir ${DEPS}/orc
-curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
-cd ${DEPS}/orc
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/vips
-curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
-cd ${DEPS}/vips
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw \
-  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
-  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
-  && make install-strip
-
-# Remove the C++ bindings
-cd ${TARGET}/include
-rm -rf vips/vipsc++.h vips/vipscpp.h vips/V*.h
-cd ${TARGET}/lib
-rm -rf pkgconfig .libs *.la libvipsCC* libvips-cpp.*
-
-# Create JSON file of version numbers
-cd ${TARGET}
-echo "{\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
-  \"ffi\": \"${VERSION_FFI}\",\n\
-  \"glib\": \"${VERSION_GLIB}\",\n\
-  \"xml\": \"${VERSION_XML2}\",\n\
-  \"gsf\": \"${VERSION_GSF}\",\n\
-  \"exif\": \"${VERSION_EXIF}\",\n\
-  \"jpeg\": \"${VERSION_JPEG}\",\n\
-  \"png\": \"${VERSION_PNG16}\",\n\
-  \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"webp\": \"${VERSION_WEBP}\",\n\
-  \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"magick\": \"${VERSION_MAGICK}\",\n\
-  \"orc\": \"${VERSION_ORC}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
-}" >lib/versions.json
-
-# Create .tar.gz
-GZIP=-9 tar czf /arm/libvips-${VERSION_VIPS}-arm.tar.gz include lib

packaging/build.sh

@@ -1,28 +0,0 @@
-#!/bin/sh
-
-# Is docker available?
-
-if ! type docker >/dev/null; then
-  echo "Please install docker"
-  exit 1
-fi
-
-# TODO: docker v1.9.0 will allow build-time args - https://github.com/docker/docker/pull/15182
-
-# Windows
-
-docker build -t vips-dev-win win
-WIN_CONTAINER_ID=$(docker run -d vips-dev-win)
-docker cp $WIN_CONTAINER_ID:/libvips-8.2.0-win.tar.gz .
-docker rm $WIN_CONTAINER_ID
-
-# Linux
-
-docker build -t vips-dev-lin lin
-LIN_CONTAINER_ID=$(docker run -d vips-dev-lin)
-docker cp $LIN_CONTAINER_ID:/libvips-8.2.0-lin.tar.gz .
-docker rm $LIN_CONTAINER_ID
-
-# Checksums
-
-sha256sum *.tar.gz

packaging/lin/Dockerfile

@@ -1,137 +0,0 @@
-FROM debian:wheezy
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-# Build dependencies
-RUN apt-get update && apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo
-
-# Create working directories
-ENV DEPS=/deps \
-    TARGET=/target
-RUN mkdir ${DEPS} && mkdir ${TARGET}
-
-# Common build paths and flags
-ENV PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig \
-    PATH=${PATH}:${TARGET}/bin \
-    CPPFLAGS=-I${TARGET}/include \
-    LDFLAGS=-L${TARGET}/lib
-
-# Dependency version numbers
-ENV VERSION_ZLIB=1.2.8 \
-    VERSION_FFI=3.2.1 \
-    VERSION_GLIB=2.46.2 \
-    VERSION_XML2=2.9.3 \
-    VERSION_GSF=1.14.34 \
-    VERSION_EXIF=0.6.21 \
-    VERSION_JPEG=1.4.2 \
-    VERSION_PNG16=1.6.20 \
-    VERSION_LCMS2=2.7 \
-    VERSION_WEBP=0.5.0 \
-    VERSION_TIFF=4.0.6 \
-    VERSION_MAGICK=6.9.2-10 \
-    VERSION_ORC=0.4.24 \
-    VERSION_VIPS=8.2.0
-
-RUN mkdir ${DEPS}/zlib
-RUN curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
-WORKDIR ${DEPS}/zlib
-RUN ./configure --prefix=${TARGET} && make install
-RUN rm ${TARGET}/lib/libz.a
-
-RUN mkdir ${DEPS}/ffi
-RUN curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
-WORKDIR ${DEPS}/ffi
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
-
-RUN mkdir ${DEPS}/glib
-RUN curl -Ls http://ftp.gnome.org/pub/gnome/sources/glib/2.46/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
-WORKDIR ${DEPS}/glib
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/xml2
-RUN curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
-WORKDIR ${DEPS}/xml2
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-python --with-zlib=${TARGET} && make install-strip
-
-RUN mkdir ${DEPS}/gsf
-RUN curl -Ls http://ftp.gnome.org/pub/GNOME/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
-WORKDIR ${DEPS}/gsf
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/exif
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
-WORKDIR ${DEPS}/exif
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/jpeg
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
-WORKDIR ${DEPS}/jpeg
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
-
-RUN mkdir ${DEPS}/png16
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
-WORKDIR ${DEPS}/png16
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/lcms2
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
-WORKDIR ${DEPS}/lcms2
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/webp
-RUN curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
-WORKDIR ${DEPS}/webp
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/tiff
-RUN curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz /deps/tiff.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
-WORKDIR ${DEPS}/tiff
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-RUN rm ${TARGET}/lib/libtiffxx*
-
-RUN mkdir ${DEPS}/magick
-RUN curl -Ls http://www.imagemagick.org/download/releases/ImageMagick-${VERSION_MAGICK}.tar.xz | tar xJC ${DEPS}/magick --strip-components=1
-WORKDIR ${DEPS}/magick
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
-RUN mkdir ${DEPS}/orc
-RUN curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
-WORKDIR ${DEPS}/orc
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/vips
-RUN curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
-WORKDIR ${DEPS}/vips
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw \
-  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
-  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
-  && make install-strip
-
-# Remove the C++ bindings
-WORKDIR ${TARGET}/include
-RUN rm -rf vips/vipsc++.h vips/vipscpp.h vips/V*.h
-WORKDIR ${TARGET}/lib
-RUN rm -rf pkgconfig .libs *.la libvipsCC* libvips-cpp.*
-
-# Create JSON file of version numbers
-WORKDIR ${TARGET}
-RUN echo "{\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
-  \"ffi\": \"${VERSION_FFI}\",\n\
-  \"glib\": \"${VERSION_GLIB}\",\n\
-  \"xml\": \"${VERSION_XML2}\",\n\
-  \"gsf\": \"${VERSION_GSF}\",\n\
-  \"exif\": \"${VERSION_EXIF}\",\n\
-  \"jpeg\": \"${VERSION_JPEG}\",\n\
-  \"png\": \"${VERSION_PNG16}\",\n\
-  \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"webp\": \"${VERSION_WEBP}\",\n\
-  \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"magick\": \"${VERSION_MAGICK}\",\n\
-  \"orc\": \"${VERSION_ORC}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
-}" >lib/versions.json
-
-# Create .tar.gz
-WORKDIR ${TARGET}
-RUN GZIP=-9 tar czf /libvips-${VERSION_VIPS}-lin.tar.gz include lib

packaging/test.sh

@@ -1,50 +0,0 @@
-#!/bin/sh
-
-# Verify docker is available
-if ! type docker >/dev/null; then
-  echo "Please install docker"
-  exit 1
-fi
-
-test="npm run clean; NODE_ENV=development npm install --unsafe-perm; npm test"
-
-# Debian 7, 8
-# Ubuntu 12.04, 14.04
-for dist in wheezy jessie precise trusty; do
-  echo "Testing $dist..."
-  if docker run -i -t --rm -v $PWD:/v nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
-  then echo "$dist OK"
-  else echo "$dist fail" && cat packaging/$dist.log
-  fi
-done
-
-# Centos 6
-echo "Testing centos6..."
-if docker run -i -t --rm -v $PWD:/v nodesource/centos6:0.12 >packaging/centos6.log 2>&1 sh -c "cd /v; source ./packaging/test/centos6.sh; ./preinstall.sh; $test";
-then echo "centos6 OK"
-else echo "centos6 fail" && cat packaging/centos6.log
-fi
-
-# Centos 7
-# Fedora 20, 21
-for dist in centos7 fedora20 fedora21; do
-  echo "Testing $dist..."
-  if docker run -i -t --rm -v $PWD:/v nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
-  then echo "$dist OK"
-  else echo "$dist fail" && cat packaging/$dist.log
-  fi
-done
-
-# openSUSE 13.2
-echo "Testing opensuse..."
-if docker run -i -t --rm -v $PWD:/v opensuse:13.2 >packaging/opensuse.log 2>&1 /bin/sh -c "cd /v; ./packaging/test/opensuse.sh; $test";
-then echo "opensuse OK"
-else echo "opensuse fail" && cat packaging/opensuse.log
-fi
-
-# Archlinux 2015.06.01
-echo "Testing archlinux..."
-if docker run -i -t --rm -v $PWD:/v base/archlinux:2015.06.01 >packaging/archlinux.log 2>&1 sh -c "cd /v; ./packaging/test/archlinux.sh; $test";
-then echo "archlinux OK"
-else echo "archlinux fail" && cat packaging/archlinux.log
-fi

packaging/test/archlinux.sh

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

packaging/test/centos6.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-# Install C++11 compatible version of g++ on Centos 6
-curl -o /etc/yum.repos.d/devtools-1.1.repo http://people.centos.org/tru/devtools-1.1/devtools-1.1.repo
-yum install -y devtoolset-1.1
-export CC=/opt/centos/devtoolset-1.1/root/usr/bin/gcc
-export CPP=/opt/centos/devtoolset-1.1/root/usr/bin/cpp
-export CXX=/opt/centos/devtoolset-1.1/root/usr/bin/c++

packaging/test/debian.sh

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

packaging/test/opensuse.sh

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

packaging/win/Dockerfile

@@ -1,17 +0,0 @@
-FROM ubuntu:precise
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-RUN apt-get update && apt-get install -y curl zip
-
-# Fetch and unzip
-RUN mkdir /vips
-WORKDIR /vips
-RUN curl -O http://www.vips.ecs.soton.ac.uk/supported/8.2/win32/vips-dev-w64-8.2.zip
-RUN unzip vips-dev-w64-8.2.zip
-
-# Clean and zip
-WORKDIR /vips/vips-dev-8.2
-RUN rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll bin/libstdc++-6.dll
-RUN cp bin/*.dll lib/
-RUN cp -r lib64/* lib/
-RUN GZIP=-9 tar czf /libvips-8.2.0-win.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll

preinstall.sh

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

src/common.h

@@ -1,18 +1,169 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #ifndef SRC_COMMON_H_
 #define SRC_COMMON_H_
 
 #include <string>
+#include <tuple>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 13) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 13 && VIPS_MICRO_VERSION < 2)
+#error "libvips version 8.13.2+ is required - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
+#error "GCC version 4.6+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if (defined(__clang__) && defined(__has_feature))
+#if (!__has_feature(cxx_range_for))
+#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+#endif
+
+using vips::VImage;
 
 namespace sharp {
 
+  struct InputDescriptor {  // NOLINT(runtime/indentation_namespace)
+    std::string name;
+    std::string file;
+    char *buffer;
+    VipsFailOn failOn;
+    uint64_t 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;
+    std::vector<double> createBackground;
+    std::string createNoiseType;
+    double createNoiseMean;
+    double createNoiseSigma;
+    std::string textValue;
+    std::string textFont;
+    std::string textFontfile;
+    int textWidth;
+    int textHeight;
+    VipsAlign textAlign;
+    bool textJustify;
+    int textDpi;
+    bool textRgba;
+    int textSpacing;
+    int textAutofitDpi;
+
+    InputDescriptor():
+      buffer(nullptr),
+      failOn(VIPS_FAIL_ON_WARNING),
+      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),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0),
+      textWidth(0),
+      textHeight(0),
+      textAlign(VIPS_ALIGN_LOW),
+      textJustify(FALSE),
+      textDpi(72),
+      textRgba(FALSE),
+      textSpacing(0),
+      textAutofitDpi(0) {}
+  };
+
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
+  double AttrAsDouble(Napi::Object obj, std::string attr);
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr);
+  bool AttrAsBool(Napi::Object obj, std::string attr);
+  std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr);
+  std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr);
+  template <class T> T AttrAsEnum(Napi::Object obj, std::string attr, GType type) {
+    return static_cast<T>(
+      vips_enum_from_nick(nullptr, type, AttrAsStr(obj, attr).data()));
+  }
+
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input);
+
   enum class ImageType {
-    UNKNOWN,
     JPEG,
     PNG,
     WEBP,
+    JP2,
     TIFF,
+    GIF,
+    SVG,
+    HEIF,
+    PDF,
     MAGICK,
-    OPENSLIDE
+    OPENSLIDE,
+    PPM,
+    FITS,
+    EXR,
+    VIPS,
+    RAW,
+    UNKNOWN,
+    MISSING
+  };
+
+  enum class Canvas {
+      CROP,
+      EMBED,
+      MAX,
+      MIN,
+      IGNORE_ASPECT
   };
 
   // How many tasks are in the queue?
@@ -25,8 +176,20 @@ 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);
+  bool IsHeif(std::string const &str);
+  bool IsAvif(std::string const &str);
   bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
+
+  /*
+    Provide a string identifier for the given image type.
+  */
+  std::string ImageTypeId(ImageType const imageType);
 
   /*
     Determine image format of a buffer.
@@ -39,51 +202,168 @@ namespace sharp {
   ImageType DetermineImageType(char const *file);
 
   /*
-    Initialise and return a VipsImage from a buffer. Supports JPEG, PNG, WebP and TIFF.
+    Does this image type support multiple pages?
   */
-  VipsImage* InitImage(void *buffer, size_t const length, VipsAccess const access);
+  bool ImageTypeSupportsPage(ImageType imageType);
 
   /*
-    Initialise and return a VipsImage from a file.
+    Does this image type support removal of safety limits?
   */
-  VipsImage* InitImage(char const *file, VipsAccess const access);
+  bool ImageTypeSupportsUnlimited(ImageType imageType);
+
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor);
 
   /*
     Does this image have an embedded profile?
   */
-  bool HasProfile(VipsImage *image);
+  bool HasProfile(VImage image);
 
   /*
     Does this image have an alpha channel?
     Uses colour space interpretation with number of channels to guess this.
   */
-  bool HasAlpha(VipsImage *image);
+  bool HasAlpha(VImage image);
 
   /*
     Get EXIF Orientation of image, if any.
   */
-  int ExifOrientation(VipsImage const *image);
+  int ExifOrientation(VImage image);
 
   /*
     Set EXIF Orientation of image.
   */
-  void SetExifOrientation(VipsImage *image, int const orientation);
+  VImage SetExifOrientation(VImage image, int const orientation);
 
   /*
     Remove EXIF Orientation from image.
   */
-  void RemoveExifOrientation(VipsImage *image);
+  VImage RemoveExifOrientation(VImage image);
 
   /*
-    Returns the window size for the named interpolator. For example,
-    a window size of 3 means a 3x3 pixel grid is used for the calculation.
+    Set animation properties if necessary.
   */
-  int InterpolatorWindowSize(char const *name);
+  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?
+  */
+  bool HasDensity(VImage image);
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image);
+
+  /*
+    Set pixels/mm resolution based on a pixels/inch density.
+  */
+  VImage SetDensity(VImage image, const double density);
+
+  /*
+    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.
+  */
+  void AssertImageTypeDimensions(VImage image, ImageType const imageType);
 
   /*
     Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
   */
-  void FreeCallback(char* data, void* hint);
+  extern std::function<void(void*, char*)> FreeCallback;
+
+  /*
+    Called with warnings from the glib-registered "VIPS" domain
+  */
+  void VipsWarningCallback(char const* log_domain, GLogLevelFlags log_level, char const* message, void* ignore);
+
+  /*
+    Pop the oldest warning message from the queue
+  */
+  std::string VipsWarningPop();
+
+  /*
+    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.
+  */
+  std::tuple<int, int> CalculateEmbedPosition(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Convert RGBA value to another colourspace
+  */
+  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, bool premultiply);
+
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image);
+
+  /*
+    Ensures alpha channel, if missing.
+  */
+  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, bool withoutReduction);
 
 }  // namespace sharp
 

src/libvips/cplusplus/VConnection.cpp

@@ -0,0 +1,151 @@
+/* Object part of the VSource and VTarget class
+ */
+
+/*
+
+    Copyright (C) 1991-2001 The National Gallery
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301  USA
+
+ */
+
+/*
+
+    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+
+#include <vips/vips8>
+
+#include <vips/debug.h>
+
+/*
+#define VIPS_DEBUG
+#define VIPS_DEBUG_VERBOSE
+ */
+
+VIPS_NAMESPACE_START
+
+VSource 
+VSource::new_from_descriptor( int descriptor )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_descriptor( descriptor )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_file( const char *filename )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_file( filename )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_blob( VipsBlob *blob )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_blob( blob )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_memory( const void *data, 
+	size_t size )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_memory( data, size )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_options( const char *options )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_options( options )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_descriptor( int descriptor )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_descriptor( descriptor )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_file( const char *filename )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_file( filename )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_memory()
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_memory()) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VIPS_NAMESPACE_END

src/libvips/cplusplus/VError.cpp

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

src/libvips/cplusplus/VInterpolate.cpp

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

src/libvips/cplusplus/VRegion.cpp

@@ -0,0 +1,27 @@
+// Object part of VRegion class
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+
+#include <vips/vips8>
+
+#include <vips/debug.h>
+
+VIPS_NAMESPACE_START
+
+VRegion
+VRegion::new_from_image( VImage image )
+{
+	VipsRegion *region;
+
+	if( !(region = vips_region_new( image.get_image() )) ) {
+		throw VError();
+	}
+
+	VRegion out( region );
+
+	return( out );
+}
+
+VIPS_NAMESPACE_END

src/metadata.cc

@@ -1,233 +1,291 @@
-#include <node.h>
-#include <vips/vips.h>
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
-#include "nan.h"
+#include <numeric>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
 
 #include "common.h"
 #include "metadata.h"
 
-using v8::Handle;
-using v8::Local;
-using v8::Value;
-using v8::Object;
-using v8::Number;
-using v8::String;
-using v8::Boolean;
-using v8::Function;
-using v8::Exception;
-
-using Nan::AsyncQueueWorker;
-using Nan::AsyncWorker;
-using Nan::Callback;
-using Nan::HandleScope;
-using Nan::Utf8String;
-using Nan::Has;
-using Nan::Get;
-using Nan::Set;
-using Nan::New;
-using Nan::NewBuffer;
-using Nan::Null;
-using Nan::Error;
-
-using sharp::ImageType;
-using sharp::DetermineImageType;
-using sharp::InitImage;
-using sharp::HasProfile;
-using sharp::HasAlpha;
-using sharp::ExifOrientation;
-using sharp::FreeCallback;
-using sharp::counterQueue;
-
-struct MetadataBaton {
-  // Input
-  std::string fileIn;
-  char *bufferIn;
-  size_t bufferInLength;
-  // Output
-  std::string format;
-  int width;
-  int height;
-  std::string space;
-  int channels;
-  bool hasProfile;
-  bool hasAlpha;
-  int orientation;
-  char *exif;
-  size_t exifLength;
-  char *icc;
-  size_t iccLength;
-  std::string err;
-
-  MetadataBaton():
-    bufferInLength(0),
-    orientation(0),
-    exifLength(0),
-    iccLength(0) {}
-};
-
-class MetadataWorker : public AsyncWorker {
-
+class MetadataWorker : public Napi::AsyncWorker {
  public:
-  MetadataWorker(Callback *callback, MetadataBaton *baton, const Local<Object> &bufferIn) :
-    AsyncWorker(callback), baton(baton) {
-      if (baton->bufferInLength > 0) {
-        SaveToPersistent("bufferIn", bufferIn);
-      }
-    }
+  MetadataWorker(Napi::Function callback, MetadataBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
   ~MetadataWorker() {}
 
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&counterQueue);
+    g_atomic_int_dec_and_test(&sharp::counterQueue);
 
-    ImageType imageType = ImageType::UNKNOWN;
-    VipsImage *image = nullptr;
-    if (baton->bufferInLength > 0) {
-      // From buffer
-      imageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
-      if (imageType != ImageType::UNKNOWN) {
-        image = InitImage(baton->bufferIn, baton->bufferInLength, VIPS_ACCESS_RANDOM);
-        if (image == nullptr) {
-          (baton->err).append("Input buffer has corrupt header");
-          imageType = ImageType::UNKNOWN;
-        }
-      } else {
-        (baton->err).append("Input buffer contains unsupported image format");
-      }
-    } else {
-      // From file
-      imageType = DetermineImageType(baton->fileIn.data());
-      if (imageType != ImageType::UNKNOWN) {
-        image = InitImage(baton->fileIn.data(), VIPS_ACCESS_RANDOM);
-        if (image == nullptr) {
-          (baton->err).append("Input file has corrupt header");
-          imageType = ImageType::UNKNOWN;
-        }
-      } else {
-        (baton->err).append("Input file is of an unsupported image format");
-      }
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
     }
-    if (image != nullptr && imageType != ImageType::UNKNOWN) {
+    if (imageType != sharp::ImageType::UNKNOWN) {
       // Image type
-      switch (imageType) {
-        case ImageType::JPEG: baton->format = "jpeg"; break;
-        case ImageType::PNG: baton->format = "png"; break;
-        case ImageType::WEBP: baton->format = "webp"; break;
-        case ImageType::TIFF: baton->format = "tiff"; break;
-        case ImageType::MAGICK: baton->format = "magick"; break;
-        case ImageType::OPENSLIDE: baton->format = "openslide"; break;
-        case ImageType::UNKNOWN: break;
-      }
+      baton->format = sharp::ImageTypeId(imageType);
       // VipsImage attributes
-      baton->width = image->Xsize;
-      baton->height = image->Ysize;
-      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image->Type);
-      baton->channels = image->Bands;
-      baton->hasProfile = HasProfile(image);
-      // Derived attributes
-      baton->hasAlpha = HasAlpha(image);
-      baton->orientation = ExifOrientation(image);
-      // EXIF
-      if (vips_image_get_typeof(image, VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
-        void* exif;
-        size_t exifLength;
-        if (!vips_image_get_blob(image, VIPS_META_EXIF_NAME, &exif, &exifLength)) {
-          baton->exifLength = exifLength;
-          baton->exif = static_cast<char*>(g_malloc(exifLength));
-          memcpy(baton->exif, exif, exifLength);
+      baton->width = image.width();
+      baton->height = image.height();
+      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
+      baton->channels = image.bands();
+      baton->depth = vips_enum_nick(VIPS_TYPE_BAND_FORMAT, image.format());
+      if (sharp::HasDensity(image)) {
+        baton->density = sharp::GetDensity(image);
+      }
+      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
+        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
+      }
+      if (image.get_typeof("interlaced") == G_TYPE_INT) {
+        baton->isProgressive = image.get_int("interlaced") == 1;
+      }
+      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
+        baton->paletteBitDepth = image.get_int("palette-bit-depth");
+      }
+      if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
+        baton->pages = image.get_int(VIPS_META_N_PAGES);
+      }
+      if (image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
+        baton->pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+      }
+      if (image.get_typeof("loop") == G_TYPE_INT) {
+        baton->loop = image.get_int("loop");
+      }
+      if (image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
+        baton->delay = image.get_array_int("delay");
+      }
+      if (image.get_typeof("heif-primary") == G_TYPE_INT) {
+        baton->pagePrimary = image.get_int("heif-primary");
+      }
+      if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
+        baton->compression = image.get_string("heif-compression");
+      }
+      if (image.get_typeof(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++) {
+          std::string prefix = "openslide.level[" + std::to_string(l) + "].";
+          int const width = std::stoi(image.get_string((prefix + "width").data()));
+          int const height = std::stoi(image.get_string((prefix + "height").data()));
+          baton->levels.push_back(std::pair<int, int>(width, height));
         }
       }
+      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
+        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
+      }
+      baton->hasProfile = sharp::HasProfile(image);
+      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);
+      // EXIF
+      if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
+        size_t exifLength;
+        void const *exif = image.get_blob(VIPS_META_EXIF_NAME, &exifLength);
+        baton->exif = static_cast<char*>(g_malloc(exifLength));
+        memcpy(baton->exif, exif, exifLength);
+        baton->exifLength = exifLength;
+      }
       // ICC profile
-      if (vips_image_get_typeof(image, VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
-        void* icc;
+      if (image.get_typeof(VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
         size_t iccLength;
-        if (!vips_image_get_blob(image, VIPS_META_ICC_NAME, &icc, &iccLength)) {
-          baton->iccLength = iccLength;
-          baton->icc = static_cast<char*>(g_malloc(iccLength));
-          memcpy(baton->icc, icc, iccLength);
-        }
+        void const *icc = image.get_blob(VIPS_META_ICC_NAME, &iccLength);
+        baton->icc = static_cast<char*>(g_malloc(iccLength));
+        memcpy(baton->icc, icc, iccLength);
+        baton->iccLength = iccLength;
+      }
+      // IPTC
+      if (image.get_typeof(VIPS_META_IPTC_NAME) == VIPS_TYPE_BLOB) {
+        size_t iptcLength;
+        void const *iptc = image.get_blob(VIPS_META_IPTC_NAME, &iptcLength);
+        baton->iptc = static_cast<char *>(g_malloc(iptcLength));
+        memcpy(baton->iptc, iptc, iptcLength);
+        baton->iptcLength = iptcLength;
+      }
+      // XMP
+      if (image.get_typeof(VIPS_META_XMP_NAME) == VIPS_TYPE_BLOB) {
+        size_t xmpLength;
+        void const *xmp = image.get_blob(VIPS_META_XMP_NAME, &xmpLength);
+        baton->xmp = static_cast<char *>(g_malloc(xmpLength));
+        memcpy(baton->xmp, xmp, xmpLength);
+        baton->xmpLength = xmpLength;
+      }
+      // TIFFTAG_PHOTOSHOP
+      if (image.get_typeof(VIPS_META_PHOTOSHOP_NAME) == VIPS_TYPE_BLOB) {
+        size_t tifftagPhotoshopLength;
+        void const *tifftagPhotoshop = image.get_blob(VIPS_META_PHOTOSHOP_NAME, &tifftagPhotoshopLength);
+        baton->tifftagPhotoshop = static_cast<char *>(g_malloc(tifftagPhotoshopLength));
+        memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
+        baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
       }
-      // Drop image reference
-      g_object_unref(image);
     }
+
     // Clean up
     vips_error_clear();
     vips_thread_shutdown();
   }
 
-  void HandleOKCallback () {
-    HandleScope();
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
 
-    Local<Value> argv[2] = { Null(), Null() };
-    if (!baton->err.empty()) {
-      // Error
-      argv[0] = Error(baton->err.data());
-    } else {
-      // Metadata Object
-      Local<Object> info = New<Object>();
-      Set(info, New("format").ToLocalChecked(), New<String>(baton->format).ToLocalChecked());
-      Set(info, New("width").ToLocalChecked(), New<Number>(baton->width));
-      Set(info, New("height").ToLocalChecked(), New<Number>(baton->height));
-      Set(info, New("space").ToLocalChecked(), New<String>(baton->space).ToLocalChecked());
-      Set(info, New("channels").ToLocalChecked(), New<Number>(baton->channels));
-      Set(info, New("hasProfile").ToLocalChecked(), New<Boolean>(baton->hasProfile));
-      Set(info, New("hasAlpha").ToLocalChecked(), New<Boolean>(baton->hasAlpha));
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call({ Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
+      Napi::Object info = Napi::Object::New(env);
+      info.Set("format", baton->format);
+      if (baton->input->bufferLength > 0) {
+        info.Set("size", baton->input->bufferLength);
+      }
+      info.Set("width", baton->width);
+      info.Set("height", baton->height);
+      info.Set("space", baton->space);
+      info.Set("channels", baton->channels);
+      info.Set("depth", baton->depth);
+      if (baton->density > 0) {
+        info.Set("density", baton->density);
+      }
+      if (!baton->chromaSubsampling.empty()) {
+        info.Set("chromaSubsampling", baton->chromaSubsampling);
+      }
+      info.Set("isProgressive", baton->isProgressive);
+      if (baton->paletteBitDepth > 0) {
+        info.Set("paletteBitDepth", baton->paletteBitDepth);
+      }
+      if (baton->pages > 0) {
+        info.Set("pages", baton->pages);
+      }
+      if (baton->pageHeight > 0) {
+        info.Set("pageHeight", baton->pageHeight);
+      }
+      if (baton->loop >= 0) {
+        info.Set("loop", baton->loop);
+      }
+      if (!baton->delay.empty()) {
+        int i = 0;
+        Napi::Array delay = Napi::Array::New(env, static_cast<size_t>(baton->delay.size()));
+        for (int const d : baton->delay) {
+          delay.Set(i++, d);
+        }
+        info.Set("delay", delay);
+      }
+      if (baton->pagePrimary > -1) {
+        info.Set("pagePrimary", baton->pagePrimary);
+      }
+      if (!baton->compression.empty()) {
+        info.Set("compression", baton->compression);
+      }
+      if (!baton->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()));
+        for (std::pair<int, int> const &l : baton->levels) {
+          Napi::Object level = Napi::Object::New(env);
+          level.Set("width", l.first);
+          level.Set("height", l.second);
+          levels.Set(i++, level);
+        }
+        info.Set("levels", levels);
+      }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
+      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) {
-        Set(info, New("orientation").ToLocalChecked(), New<Number>(baton->orientation));
+        info.Set("orientation", baton->orientation);
       }
       if (baton->exifLength > 0) {
-        Set(info,
-          New("exif").ToLocalChecked(),
-          NewBuffer(baton->exif, baton->exifLength, FreeCallback, nullptr).ToLocalChecked()
-        );
+        info.Set("exif", Napi::Buffer<char>::New(env, baton->exif, baton->exifLength, sharp::FreeCallback));
       }
       if (baton->iccLength > 0) {
-        Set(info,
-          New("icc").ToLocalChecked(),
-          NewBuffer(baton->icc, baton->iccLength, FreeCallback, nullptr).ToLocalChecked()
-        );
+        info.Set("icc", Napi::Buffer<char>::New(env, baton->icc, baton->iccLength, sharp::FreeCallback));
       }
-      argv[1] = info;
+      if (baton->iptcLength > 0) {
+        info.Set("iptc", Napi::Buffer<char>::New(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
+      }
+      if (baton->xmpLength > 0) {
+        info.Set("xmp", Napi::Buffer<char>::New(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
+      }
+      if (baton->tifftagPhotoshopLength > 0) {
+        info.Set("tifftagPhotoshop",
+          Napi::Buffer<char>::New(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback));
+      }
+      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
     }
 
-    // Dispose of Persistent wrapper around input Buffer so it can be garbage collected
-    if (baton->bufferInLength > 0) {
-      GetFromPersistent("bufferIn");
-    }
+    delete baton->input;
     delete baton;
-
-    // Return to JavaScript
-    callback->Call(2, argv);
   }
 
  private:
   MetadataBaton* baton;
+  Napi::FunctionReference debuglog;
 };
 
 /*
   metadata(options, callback)
 */
-NAN_METHOD(metadata) {
-  HandleScope();
-
+Napi::Value metadata(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   MetadataBaton *baton = new MetadataBaton;
-  Local<Object> options = info[0].As<Object>();
+  Napi::Object options = info[0].As<Napi::Object>();
 
-  // Input filename
-  baton->fileIn = *Utf8String(Get(options, New("fileIn").ToLocalChecked()).ToLocalChecked());
-  // Input Buffer object
-  Local<Object> bufferIn;
-  if (node::Buffer::HasInstance(Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked())) {
-    bufferIn = Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked().As<Object>();
-    baton->bufferInLength = node::Buffer::Length(bufferIn);
-    baton->bufferIn = node::Buffer::Data(bufferIn);
-  }
+  // Input
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+
+  // Function to notify of libvips warnings
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
 
   // Join queue for worker thread
-  Callback *callback = new Callback(info[1].As<Function>());
-  AsyncQueueWorker(new MetadataWorker(callback, baton, bufferIn));
+  Napi::Function callback = info[1].As<Napi::Function>();
+  MetadataWorker *worker = new MetadataWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
 
   // Increment queued task counter
-  g_atomic_int_inc(&counterQueue);
+  g_atomic_int_inc(&sharp::counterQueue);
+
+  return info.Env().Undefined();
 }

src/metadata.h

@@ -1,8 +1,92 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #ifndef SRC_METADATA_H_
 #define SRC_METADATA_H_
 
-#include "nan.h"
+#include <string>
+#include <napi.h>
 
-NAN_METHOD(metadata);
+#include "./common.h"
+
+struct MetadataBaton {
+  // Input
+  sharp::InputDescriptor *input;
+  // Output
+  std::string format;
+  int width;
+  int height;
+  std::string space;
+  int channels;
+  std::string depth;
+  int density;
+  std::string chromaSubsampling;
+  bool isProgressive;
+  int paletteBitDepth;
+  int pages;
+  int pageHeight;
+  int loop;
+  std::vector<int> delay;
+  int pagePrimary;
+  std::string compression;
+  std::string resolutionUnit;
+  std::vector<std::pair<int, int>> levels;
+  int subifds;
+  std::vector<double> background;
+  bool hasProfile;
+  bool hasAlpha;
+  int orientation;
+  char *exif;
+  size_t exifLength;
+  char *icc;
+  size_t iccLength;
+  char *iptc;
+  size_t iptcLength;
+  char *xmp;
+  size_t xmpLength;
+  char *tifftagPhotoshop;
+  size_t tifftagPhotoshopLength;
+  std::string err;
+
+  MetadataBaton():
+    input(nullptr),
+    width(0),
+    height(0),
+    channels(0),
+    density(0),
+    isProgressive(false),
+    paletteBitDepth(0),
+    pages(0),
+    pageHeight(0),
+    loop(-1),
+    pagePrimary(-1),
+    subifds(0),
+    hasProfile(false),
+    hasAlpha(false),
+    orientation(0),
+    exif(nullptr),
+    exifLength(0),
+    icc(nullptr),
+    iccLength(0),
+    iptc(nullptr),
+    iptcLength(0),
+    xmp(nullptr),
+    xmpLength(0),
+    tifftagPhotoshop(nullptr),
+    tifftagPhotoshopLength(0) {}
+};
+
+Napi::Value metadata(const Napi::CallbackInfo& info);
 
 #endif  // SRC_METADATA_H_

src/operations.cc

@@ -1,282 +1,459 @@
-#include <vips/vips.h>
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include <vips/vips8>
 
 #include "common.h"
 #include "operations.h"
 
+using vips::VImage;
+using vips::VError;
+
 namespace sharp {
-
   /*
-    Alpha composite src over dst
-    Assumes alpha channels are already premultiplied and will be unpremultiplied after
+   * Tint an image using the specified chroma, preserving the original image luminance
    */
-  int Composite(VipsObject *context, VipsImage *src, VipsImage *dst, VipsImage **out) {
-    using sharp::HasAlpha;
-
-    // Split src into non-alpha and alpha
-    VipsImage *srcWithoutAlpha;
-    if (vips_extract_band(src, &srcWithoutAlpha, 0, "n", src->Bands - 1, nullptr))
-      return -1;
-    vips_object_local(context, srcWithoutAlpha);
-    VipsImage *srcAlpha;
-    if (vips_extract_band(src, &srcAlpha, src->Bands - 1, "n", 1, nullptr))
-      return -1;
-    vips_object_local(context, srcAlpha);
-
-    // Split dst into non-alpha and alpha channels
-    VipsImage *dstWithoutAlpha;
-    VipsImage *dstAlpha;
-    if (HasAlpha(dst)) {
-      // Non-alpha: extract all-but-last channel
-      if (vips_extract_band(dst, &dstWithoutAlpha, 0, "n", dst->Bands - 1, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, dstWithoutAlpha);
-      // Alpha: Extract last channel
-      if (vips_extract_band(dst, &dstAlpha, dst->Bands - 1, "n", 1, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, dstAlpha);
-    } else {
-      // Non-alpha: Copy reference
-      dstWithoutAlpha = dst;
-      // Alpha: Use blank, opaque (0xFF) image
-      VipsImage *black;
-      if (vips_black(&black, dst->Xsize, dst->Ysize, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, black);
-      if (vips_invert(black, &dstAlpha, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, dstAlpha);
+  VImage Tint(VImage image, double const a, double const b) {
+    // Get original colourspace
+    VipsInterpretation typeBeforeTint = image.interpretation();
+    if (typeBeforeTint == VIPS_INTERPRETATION_RGB) {
+      typeBeforeTint = VIPS_INTERPRETATION_sRGB;
     }
-
-    // Compute normalized input alpha channels:
-    VipsImage *srcAlphaNormalized;
-    if (vips_linear1(srcAlpha, &srcAlphaNormalized, 1.0 / 255.0, 0.0, nullptr))
-      return -1;
-    vips_object_local(context, srcAlphaNormalized);
-
-    VipsImage *dstAlphaNormalized;
-    if (vips_linear1(dstAlpha, &dstAlphaNormalized, 1.0 / 255.0, 0.0, nullptr))
-      return -1;
-    vips_object_local(context, dstAlphaNormalized);
-
-    //
-    // Compute normalized output alpha channel:
-    //
-    // References:
-    // - http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
-    // - https://github.com/jcupitt/ruby-vips/issues/28#issuecomment-9014826
-    //
-    // out_a = src_a + dst_a * (1 - src_a)
-    //                         ^^^^^^^^^^^
-    //                            t0
-    //                 ^^^^^^^^^^^^^^^^^^^
-    //                         t1
-    VipsImage *t0;
-    if (vips_linear1(srcAlphaNormalized, &t0, -1.0, 1.0, nullptr))
-      return -1;
-    vips_object_local(context, t0);
-
-    VipsImage *t1;
-    if (vips_multiply(dstAlphaNormalized, t0, &t1, nullptr))
-      return -1;
-    vips_object_local(context, t1);
-
-    VipsImage *outAlphaNormalized;
-    if (vips_add(srcAlphaNormalized, t1, &outAlphaNormalized, nullptr))
-      return -1;
-    vips_object_local(context, outAlphaNormalized);
-
-    //
-    // Compute output RGB channels:
-    //
-    // Wikipedia:
-    // out_rgb = (src_rgb * src_a + dst_rgb * dst_a * (1 - src_a)) / out_a
-    //                                                ^^^^^^^^^^^
-    //                                                    t0
-    //
-    // Omit division by `out_a` since `Compose` is supposed to output a
-    // premultiplied RGBA image as reversal of premultiplication is handled
-    // externally.
-    //
-    VipsImage *t2;
-    if (vips_multiply(dstWithoutAlpha, t0, &t2, nullptr))
-      return -1;
-    vips_object_local(context, t2);
-
-    VipsImage *outRGBPremultiplied;
-    if (vips_add(srcWithoutAlpha, t2, &outRGBPremultiplied, nullptr))
-      return -1;
-    vips_object_local(context, outRGBPremultiplied);
-
-    // Denormalize output alpha channel:
-    VipsImage *outAlpha;
-    if (vips_linear1(outAlphaNormalized, &outAlpha, 255.0, 0.0, nullptr))
-      return -1;
-    vips_object_local(context, outAlpha);
-
-    // Combine RGB and alpha channel into output image:
-    return vips_bandjoin2(outRGBPremultiplied, outAlpha, out, nullptr);
+    // Extract luminance
+    VImage luminance = image.colourspace(VIPS_INTERPRETATION_LAB)[0];
+    // Create the tinted version by combining the L from the original and the chroma from the tint
+    std::vector<double> chroma {a, b};
+    VImage tinted = luminance
+      .bandjoin(chroma)
+      .copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_LAB))
+      .colourspace(typeBeforeTint);
+    // Attach original alpha channel, if any
+    if (HasAlpha(image)) {
+      // Extract original alpha channel
+      VImage alpha = image[image.bands() - 1];
+      // Join alpha channel to normalised image
+      tinted = tinted.bandjoin(alpha);
+    }
+    return tinted;
   }
 
   /*
    * Stretch luminance to cover full dynamic range.
    */
-  int Normalize(VipsObject *context, VipsImage *image, VipsImage **out) {
+  VImage Normalise(VImage image) {
     // Get original colourspace
-    VipsInterpretation typeBeforeNormalize = image->Type;
+    VipsInterpretation typeBeforeNormalize = image.interpretation();
     if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
       typeBeforeNormalize = VIPS_INTERPRETATION_sRGB;
     }
     // Convert to LAB colourspace
-    VipsImage *lab;
-    if (vips_colourspace(image, &lab, VIPS_INTERPRETATION_LAB, nullptr)) {
-      return -1;
-    }
-    vips_object_local(context, lab);
+    VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
     // Extract luminance
-    VipsImage *luminance;
-    if (vips_extract_band(lab, &luminance, 0, "n", 1, nullptr)) {
-      return -1;
-    }
-    vips_object_local(context, luminance);
-    // Extract chroma
-    VipsImage *chroma;
-    if (vips_extract_band(lab, &chroma, 1, "n", 2, nullptr)) {
-      return -1;
-    }
-    vips_object_local(context, chroma);
+    VImage luminance = lab[0];
     // Find luminance range
-    VipsImage *stats;
-    if (vips_stats(luminance, &stats, nullptr)) {
-      return -1;
-    }
-    vips_object_local(context, stats);
-    double min = *VIPS_MATRIX(stats, 0, 0);
-    double max = *VIPS_MATRIX(stats, 1, 0);
-    if (min != max) {
+    int const min = luminance.percent(1);
+    int const max = luminance.percent(99);
+    if (std::abs(max - min) > 1) {
+      // Extract chroma
+      VImage chroma = lab.extract_band(1, VImage::option()->set("n", 2));
+      // Calculate multiplication factor and addition
       double f = 100.0 / (max - min);
       double a = -(min * f);
-      // Scale luminance
-      VipsImage *luminance100;
-      if (vips_linear1(luminance, &luminance100, f, a, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, luminance100);
-      // Join scaled luminance to chroma
-      VipsImage *normalizedLab;
-      if (vips_bandjoin2(luminance100, chroma, &normalizedLab, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, normalizedLab);
-      // Convert to original colourspace
-      VipsImage *normalized;
-      if (vips_colourspace(normalizedLab, &normalized, typeBeforeNormalize, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, normalized);
+      // Scale luminance, join to chroma, convert back to original colourspace
+      VImage normalized = luminance.linear(f, a).bandjoin(chroma).colourspace(typeBeforeNormalize);
       // Attach original alpha channel, if any
       if (HasAlpha(image)) {
         // Extract original alpha channel
-        VipsImage *alpha;
-        if (vips_extract_band(image, &alpha, image->Bands - 1, "n", 1, nullptr)) {
-          return -1;
-        }
-        vips_object_local(context, alpha);
+        VImage alpha = image[image.bands() - 1];
         // Join alpha channel to normalised image
-        VipsImage *normalizedAlpha;
-        if (vips_bandjoin2(normalized, alpha, &normalizedAlpha, nullptr)) {
-          return -1;
-        }
-        vips_object_local(context, normalizedAlpha);
-        *out = normalizedAlpha;
+        return normalized.bandjoin(alpha);
       } else {
-        *out = normalized;
+        return normalized;
       }
-    } else {
-      // Cannot normalise zero-range image
-      *out = image;
     }
-    return 0;
+    return image;
   }
 
   /*
-   * Gaussian blur (use sigma <0 for fast blur)
+   * Contrast limiting adapative histogram equalization (CLAHE)
    */
-  int Blur(VipsObject *context, VipsImage *image, VipsImage **out, double sigma) {
-    VipsImage *blurred;
-    if (sigma < 0.0) {
+  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
+   */
+  VImage Gamma(VImage image, double const exponent) {
+    if (HasAlpha(image)) {
+      // Separate alpha channel
+      VImage alpha = image[image.bands() - 1];
+      return RemoveAlpha(image).gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
+    } else {
+      return image.gamma(VImage::option()->set("exponent", exponent));
+    }
+  }
+
+  /*
+   * Flatten image to remove alpha channel
+   */
+  VImage Flatten(VImage image, std::vector<double> flattenBackground) {
+    double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
+    std::vector<double> background {
+      flattenBackground[0] * multiplier,
+      flattenBackground[1] * multiplier,
+      flattenBackground[2] * multiplier
+    };
+    return image.flatten(VImage::option()->set("background", background));
+  }
+
+  /**
+   * 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.
+   */
+  VImage Blur(VImage image, double const sigma) {
+    if (sigma == -1.0) {
       // Fast, mild blur - averages neighbouring pixels
-      VipsImage *blur = vips_image_new_matrixv(3, 3,
+      VImage blur = VImage::new_matrixv(3, 3,
         1.0, 1.0, 1.0,
         1.0, 1.0, 1.0,
         1.0, 1.0, 1.0);
-      vips_image_set_double(blur, "scale", 9);
-      vips_object_local(context, blur);
-      if (vips_conv(image, &blurred, blur, nullptr)) {
-        return -1;
-      }
+      blur.set("scale", 9.0);
+      return image.conv(blur);
     } else {
       // Slower, accurate Gaussian blur
-      // Create Gaussian function for standard deviation
-      VipsImage *gaussian;
-      if (vips_gaussmat(&gaussian, sigma, 0.2, "separable", TRUE, "integer", TRUE, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, gaussian);
-      // Apply Gaussian function
-      if (vips_convsep(image, &blurred, gaussian, "precision", VIPS_PRECISION_INTEGER, nullptr)) {
-        return -1;
-      }
+      return image.gaussblur(sigma);
     }
-    vips_object_local(context, blurred);
-    *out = blurred;
-    return 0;
   }
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Convolution with a kernel.
    */
-  int Sharpen(VipsObject *context, VipsImage *image, VipsImage **out, int radius, double flat, double jagged) {
-    VipsImage *sharpened;
-    if (radius == -1) {
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset,
+    std::unique_ptr<double[]> const &kernel_v
+  ) {
+    VImage kernel = VImage::new_from_memory(
+      kernel_v.get(),
+      width * height * sizeof(double),
+      width,
+      height,
+      1,
+      VIPS_FORMAT_DOUBLE);
+    kernel.set("scale", scale);
+    kernel.set("offset", offset);
+
+    return image.conv(kernel);
+  }
+
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
+    double *m = matrix.get();
+    image = image.colourspace(VIPS_INTERPRETATION_sRGB);
+    return image
+      .recomb(image.bands() == 3
+        ? VImage::new_from_memory(
+          m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE
+        )
+        : VImage::new_matrixv(4, 4,
+          m[0], m[1], m[2], 0.0,
+          m[3], m[4], m[5], 0.0,
+          m[6], m[7], m[8], 0.0,
+          0.0, 0.0, 0.0, 1.0));
+  }
+
+  VImage Modulate(VImage image, double const brightness, double const saturation,
+                  int const hue, double const lightness) {
+    if (HasAlpha(image)) {
+      // Separate alpha channel
+      VImage alpha = image[image.bands() - 1];
+      return RemoveAlpha(image)
+        .colourspace(VIPS_INTERPRETATION_LCH)
+        .linear(
+          { brightness, saturation, 1},
+          { lightness, 0.0, static_cast<double>(hue) }
+        )
+        .colourspace(VIPS_INTERPRETATION_sRGB)
+        .bandjoin(alpha);
+    } else {
+      return image
+        .colourspace(VIPS_INTERPRETATION_LCH)
+        .linear(
+          { brightness, saturation, 1 },
+          { lightness, 0.0, static_cast<double>(hue) }
+        )
+        .colourspace(VIPS_INTERPRETATION_sRGB);
+    }
+  }
+
+  /*
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const m1, double const m2,
+    double const x1, double const y2, double const y3) {
+    if (sigma == -1.0) {
       // Fast, mild sharpen
-      VipsImage *sharpen = vips_image_new_matrixv(3, 3,
+      VImage sharpen = VImage::new_matrixv(3, 3,
         -1.0, -1.0, -1.0,
         -1.0, 32.0, -1.0,
         -1.0, -1.0, -1.0);
-      vips_image_set_double(sharpen, "scale", 24);
-      vips_object_local(context, sharpen);
-      if (vips_conv(image, &sharpened, sharpen, nullptr)) {
-        return -1;
-      }
+      sharpen.set("scale", 24.0);
+      return image.conv(sharpen);
     } else {
       // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
-      if (vips_sharpen(image, &sharpened, "radius", radius, "m1", flat, "m2", jagged, nullptr)) {
-        return -1;
+      VipsInterpretation colourspaceBeforeSharpen = image.interpretation();
+      if (colourspaceBeforeSharpen == VIPS_INTERPRETATION_RGB) {
+        colourspaceBeforeSharpen = VIPS_INTERPRETATION_sRGB;
+      }
+      return image
+        .sharpen(VImage::option()
+          ->set("sigma", sigma)
+          ->set("m1", m1)
+          ->set("m2", m2)
+          ->set("x1", x1)
+          ->set("y2", y2)
+          ->set("y3", y3))
+        .colourspace(colourspaceBeforeSharpen);
+    }
+  }
+
+  VImage Threshold(VImage image, double const threshold, bool const thresholdGrayscale) {
+    if (!thresholdGrayscale) {
+      return image >= threshold;
+    }
+    return image.colourspace(VIPS_INTERPRETATION_B_W) >= threshold;
+  }
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean) {
+    image = image.bandbool(boolean);
+    return image.copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_B_W));
+  }
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
+    return image.boolean(imageR, boolean);
+  }
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, std::vector<double> background, double threshold) {
+    if (image.width() < 3 && image.height() < 3) {
+      throw VError("Image to trim must be at least 3x3 pixels");
+    }
+
+    // Scale up 8-bit values to match 16-bit input image
+    double multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
+    threshold *= multiplier;
+
+    std::vector<double> backgroundAlpha(1);
+    if (background.size() == 0) {
+      // Top-left pixel provides the default background colour if none is given
+      background = image.extract_area(0, 0, 1, 1)(0, 0);
+      multiplier = 1.0;
+    }
+    if (HasAlpha(image) && background.size() == 4) {
+      // Just discard the alpha because flattening the background colour with
+      // itself (effectively what find_trim() does) gives the same result
+      backgroundAlpha[0] = background[3] * multiplier;
+    }
+    if (image.bands() > 2) {
+      background = {
+        background[0] * multiplier,
+        background[1] * multiplier,
+        background[2] * multiplier
+      };
+    } else {
+      background[0] = background[0] * multiplier;
+    }
+    int left, top, width, height;
+    left = image.find_trim(&top, &width, &height, VImage::option()
+      ->set("background", background)
+      ->set("threshold", threshold));
+    if (HasAlpha(image)) {
+      // Search alpha channel (A)
+      int leftA, topA, widthA, heightA;
+      VImage alpha = image[image.bands() - 1];
+      leftA = alpha.find_trim(&topA, &widthA, &heightA, VImage::option()
+        ->set("background", backgroundAlpha)
+        ->set("threshold", threshold));
+      if (widthA > 0 && heightA > 0) {
+        if (width > 0 && height > 0) {
+          // Combined bounding box (B)
+          int const leftB = std::min(left, leftA);
+          int const topB = std::min(top, topA);
+          int const widthB = std::max(left + width, leftA + widthA) - leftB;
+          int const heightB = std::max(top + height, topA + heightA) - topB;
+          return image.extract_area(leftB, topB, widthB, heightB);
+        } else {
+          // Use alpha only
+          return image.extract_area(leftA, topA, widthA, heightA);
+        }
       }
     }
-    vips_object_local(context, sharpened);
-    *out = sharpened;
-    return 0;
+    if (width > 0 && height > 0) {
+      return image.extract_area(left, top, width, height);
+    }
+    return image;
   }
 
-  int Threshold(VipsObject *context, VipsImage *image, VipsImage **out, int threshold) {
-      VipsImage *greyscale;
-      if (vips_colourspace(image, &greyscale, VIPS_INTERPRETATION_B_W, nullptr)) {
-        return -1;
-      }
-      vips_object_local(context, greyscale);
-      image = greyscale;
-
-      VipsImage *thresholded;
-      if (vips_moreeq_const1(image, &thresholded, threshold, nullptr)) {
-          return -1;
-      }
-      vips_object_local(context, thresholded);
-      *out = thresholded;
-      return 0;
+  /*
+   * Calculate (a * in + b)
+   */
+  VImage Linear(VImage image, std::vector<double> const a, std::vector<double> const b) {
+    size_t const bands = static_cast<size_t>(image.bands());
+    if (a.size() > bands) {
+      throw VError("Band expansion using linear is unsupported");
+    }
+    if (HasAlpha(image) && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {
+      // Separate alpha channel
+      VImage alpha = image[bands - 1];
+      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
+    } else {
+      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

@@ -1,34 +1,131 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #ifndef SRC_OPERATIONS_H_
 #define SRC_OPERATIONS_H_
 
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <tuple>
+#include <vips/vips8>
+
+using vips::VImage;
+
 namespace sharp {
 
   /*
-    Composite images `src` and `dst` with premultiplied alpha channel and output
-    image with premultiplied alpha.
+   * Tint an image using the specified chroma, preserving the original image luminance
    */
-  int Composite(VipsObject *context, VipsImage *src, VipsImage *dst, VipsImage **out);
+  VImage Tint(VImage image, double const a, double const b);
 
   /*
    * Stretch luminance to cover full dynamic range.
    */
-  int Normalize(VipsObject *context, VipsImage *image, VipsImage **out);
+  VImage Normalise(VImage image);
 
   /*
-   * Gaussian blur. Use sigma of -1 for fast blur.
+   * Contrast limiting adapative histogram equalization (CLAHE)
    */
-  int Blur(VipsObject *context, VipsImage *image, VipsImage **out, double sigma);
+  VImage Clahe(VImage image, int const width, int const height, int const maxSlope);
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Gamma encoding/decoding
    */
-  int Sharpen(VipsObject *context, VipsImage *image, VipsImage **out, int radius, double flat, double jagged);
+  VImage Gamma(VImage image, double const exponent);
 
   /*
-   * Perform thresholding on an image.  If the image is not greyscale, will convert before thresholding.
-   * Pixels with a greyscale value greater-than-or-equal-to `threshold` will be pure white.  All others will be pure black.
+   * Flatten image to remove alpha channel
    */
-  int Threshold(VipsObject *context, VipsImage *image, VipsImage **out, int threshold);
+  VImage Flatten(VImage image, std::vector<double> flattenBackground);
+
+  /*
+   * Produce the "negative" of the image.
+   */
+  VImage Negate(VImage image, bool const negateAlpha);
+
+  /*
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
+   */
+  VImage Blur(VImage image, double const sigma);
+
+  /*
+   * Convolution with a kernel.
+   */
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset, std::unique_ptr<double[]> const &kernel_v);
+
+  /*
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const m1, double const m2,
+    double const x1, double const y2, double const y3);
+
+  /*
+    Threshold an image
+  */
+  VImage Threshold(VImage image, double const threshold, bool const thresholdColor);
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean);
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean);
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, std::vector<double> background, double const threshold);
+
+  /*
+   * Linear adjustment (a * in + b)
+   */
+  VImage Linear(VImage image, std::vector<double> const a,  std::vector<double> const b);
+
+  /*
+   * Recomb with a Matrix of the given bands/channel size.
+   * Eg. RGB will be a 3x3 matrix.
+   */
+  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
+
+  /*
+   * Modulate brightness, saturation, hue and lightness
+   */
+  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
 
 #endif  // SRC_OPERATIONS_H_