sharp 0.33.5 → 0.35.0

package/src/pipeline.cc

@@ -1,8 +1,11 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #include <algorithm>
 #include <cmath>
+#include <filesystem>  // NOLINT(build/c++17)
 #include <map>
 #include <memory>
 #include <numeric>
@@ -16,20 +19,9 @@
 #include <vips/vips8>
 #include <napi.h>
 
-#include "common.h"
-#include "operations.h"
-#include "pipeline.h"
-
-#ifdef _WIN32
-#define STAT64_STRUCT __stat64
-#define STAT64_FUNCTION _stat64
-#elif defined(_LARGEFILE64_SOURCE)
-#define STAT64_STRUCT stat64
-#define STAT64_FUNCTION stat64
-#else
-#define STAT64_STRUCT stat
-#define STAT64_FUNCTION stat
-#endif
+#include "./common.h"
+#include "./operations.h"
+#include "./pipeline.h"
 
 class PipelineWorker : public Napi::AsyncWorker {
  public:
@@ -52,7 +44,39 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Open input
       vips::VImage image;
       sharp::ImageType inputImageType;
-      std::tie(image, inputImageType) = sharp::OpenInput(baton->input);
+      if (baton->join.empty()) {
+        std::tie(image, inputImageType) = sharp::OpenInput(baton->input);
+      } else {
+        std::vector<VImage> images;
+        bool hasAlpha = false;
+        for (auto &join : baton->join) {
+          std::tie(image, inputImageType) = sharp::OpenInput(join);
+          image = sharp::EnsureColourspace(image, baton->colourspacePipeline);
+          images.push_back(image);
+          hasAlpha |= image.has_alpha();
+        }
+        if (hasAlpha) {
+          for (auto &image : images) {
+            if (!image.has_alpha()) {
+              image = sharp::EnsureAlpha(image, 1);
+            }
+          }
+        } else {
+          baton->input->joinBackground.pop_back();
+        }
+        inputImageType = sharp::ImageType::PNG;
+        image = VImage::arrayjoin(images, VImage::option()
+          ->set("across", baton->input->joinAcross)
+          ->set("shim", baton->input->joinShim)
+          ->set("background", baton->input->joinBackground)
+          ->set("halign", baton->input->joinHalign)
+          ->set("valign", baton->input->joinValign));
+        if (baton->input->joinAnimated) {
+          image = image.copy();
+          image.set(VIPS_META_N_PAGES, static_cast<int>(images.size()));
+          image.set(VIPS_META_PAGE_HEIGHT, static_cast<int>(image.height() / images.size()));
+        }
+      }
       VipsAccess access = baton->input->access;
       image = sharp::EnsureColourspace(image, baton->colourspacePipeline);
 
@@ -60,7 +84,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (nPages == -1) {
         // Resolve the number of pages if we need to render until the end of the document
         nPages = image.get_typeof(VIPS_META_N_PAGES) != 0
-          ? image.get_int(VIPS_META_N_PAGES) - baton->input->page
+          ? image.get_int(VIPS_META_N_PAGES) - std::max(0, baton->input->page)
           : 1;
       }
 
@@ -70,31 +94,22 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Calculate angle of rotation
       VipsAngle rotation = VIPS_ANGLE_D0;
       VipsAngle autoRotation = VIPS_ANGLE_D0;
-      bool autoFlip = false;
       bool autoFlop = false;
 
-      if (baton->useExifOrientation) {
+      if (baton->input->autoOrient) {
         // Rotate and flip image according to Exif orientation
-        std::tie(autoRotation, autoFlip, autoFlop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
-        image = sharp::RemoveExifOrientation(image);
-      } else {
-        rotation = CalculateAngleRotation(baton->angle);
+        std::tie(autoRotation, autoFlop) = CalculateExifRotationAndFlop(sharp::ExifOrientation(image));
       }
 
-      // Rotate pre-extract
-      bool const shouldRotateBefore = baton->rotateBeforePreExtract &&
-        (rotation != VIPS_ANGLE_D0 || autoRotation != VIPS_ANGLE_D0 ||
-          autoFlip || baton->flip || autoFlop || baton->flop ||
-          baton->rotationAngle != 0.0);
+      rotation = CalculateAngleRotation(baton->angle);
 
-      if (shouldRotateBefore) {
-        image = sharp::StaySequential(image,
-          rotation != VIPS_ANGLE_D0 ||
-          autoRotation != VIPS_ANGLE_D0 ||
-          autoFlip ||
-          baton->flip ||
-          baton->rotationAngle != 0.0);
+      bool const shouldRotateBefore = baton->rotateBefore &&
+        (rotation != VIPS_ANGLE_D0 || baton->flip || baton->flop || baton->rotationAngle != 0.0);
+      bool const shouldOrientBefore = (shouldRotateBefore || baton->orientBefore) &&
+        (autoRotation != VIPS_ANGLE_D0 || autoFlop);
 
+      if (shouldOrientBefore) {
+        image = sharp::StaySequential(image, autoRotation != VIPS_ANGLE_D0);
         if (autoRotation != VIPS_ANGLE_D0) {
           if (autoRotation != VIPS_ANGLE_D180) {
             MultiPageUnsupported(nPages, "Rotate");
@@ -102,17 +117,19 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = image.rot(autoRotation);
           autoRotation = VIPS_ANGLE_D0;
         }
-        if (autoFlip) {
-          image = image.flip(VIPS_DIRECTION_VERTICAL);
-          autoFlip = false;
-        } else if (baton->flip) {
-          image = image.flip(VIPS_DIRECTION_VERTICAL);
-          baton->flip = false;
-        }
         if (autoFlop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
           autoFlop = false;
-        } else if (baton->flop) {
+        }
+      }
+
+      if (shouldRotateBefore) {
+        image = sharp::StaySequential(image, rotation != VIPS_ANGLE_D0 || baton->flip || baton->rotationAngle != 0.0);
+        if (baton->flip) {
+          image = image.flip(VIPS_DIRECTION_VERTICAL);
+          baton->flip = false;
+        }
+        if (baton->flop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
           baton->flop = false;
         }
@@ -128,6 +145,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           std::vector<double> background;
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, false);
           image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background)).copy_memory();
+          baton->rotationAngle = 0.0;
         }
       }
 
@@ -135,7 +153,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (baton->trimThreshold >= 0.0) {
         MultiPageUnsupported(nPages, "Trim");
         image = sharp::StaySequential(image);
-        image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold, baton->trimLineArt);
+        image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold, baton->trimLineArt, baton->trimMargin);
         baton->trimOffsetLeft = image.xoffset();
         baton->trimOffsetTop = image.yoffset();
       }
@@ -166,8 +184,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // When auto-rotating by 90 or 270 degrees, swap the target width and
       // height to ensure the behavior aligns with how it would have been if
       // the rotation had taken place *before* resizing.
-      if (!baton->rotateBeforePreExtract &&
-        (autoRotation == VIPS_ANGLE_D90 || autoRotation == VIPS_ANGLE_D270)) {
+      if (autoRotation == VIPS_ANGLE_D90 || autoRotation == VIPS_ANGLE_D270) {
         std::swap(targetResizeWidth, targetResizeHeight);
       }
 
@@ -186,10 +203,12 @@ class PipelineWorker : public Napi::AsyncWorker {
       //  - the width or height parameters are specified;
       //  - gamma correction doesn't need to be applied;
       //  - trimming or pre-resize extract isn't required;
+      //  - gain map processing is not required;
       //  - input colourspace is not specified;
       bool const shouldPreShrink = (targetResizeWidth > 0 || targetResizeHeight > 0) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold < 0.0 &&
-        baton->colourspacePipeline == VIPS_INTERPRETATION_LAST && !shouldRotateBefore;
+        !baton->keepGainMap && !baton->withGainMap &&
+        baton->colourspacePipeline == VIPS_INTERPRETATION_LAST && !(shouldOrientBefore || shouldRotateBefore);
 
       if (shouldPreShrink) {
         // The common part of the shrink: the bit by which both axes must be shrunk
@@ -223,11 +242,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // factor for jpegload*, a double scale factor for webpload*,
       // pdfload* and svgload*
       if (jpegShrinkOnLoad > 1) {
-        vips::VOption *option = VImage::option()
-          ->set("access", access)
-          ->set("shrink", jpegShrinkOnLoad)
-          ->set("unlimited", baton->input->unlimited)
-          ->set("fail_on", baton->input->failOn);
+        vips::VOption *option = GetOptionsForImageType(inputImageType, baton->input)->set("shrink", jpegShrinkOnLoad);
         if (baton->input->buffer != nullptr) {
           // Reload JPEG buffer
           VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -238,14 +253,8 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = VImage::jpegload(const_cast<char*>(baton->input->file.data()), option);
         }
       } else if (scale != 1.0) {
-        vips::VOption *option = VImage::option()
-          ->set("access", access)
-          ->set("scale", scale)
-          ->set("fail_on", baton->input->failOn);
+        vips::VOption *option = GetOptionsForImageType(inputImageType, baton->input)->set("scale", scale);
         if (inputImageType == sharp::ImageType::WEBP) {
-          option->set("n", baton->input->pages);
-          option->set("page", baton->input->page);
-
           if (baton->input->buffer != nullptr) {
             // Reload WebP buffer
             VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -256,9 +265,6 @@ class PipelineWorker : public Napi::AsyncWorker {
             image = VImage::webpload(const_cast<char*>(baton->input->file.data()), option);
           }
         } else if (inputImageType == sharp::ImageType::SVG) {
-          option->set("unlimited", baton->input->unlimited);
-          option->set("dpi", baton->input->density);
-
           if (baton->input->buffer != nullptr) {
             // Reload SVG buffer
             VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -270,13 +276,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           sharp::SetDensity(image, baton->input->density);
           if (image.width() > 32767 || image.height() > 32767) {
-            throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");
+            throw std::runtime_error("Input SVG image will exceed 32767x32767 pixel limit when scaled");
           }
         } else if (inputImageType == sharp::ImageType::PDF) {
-          option->set("n", baton->input->pages);
-          option->set("page", baton->input->page);
-          option->set("dpi", baton->input->density);
-
           if (baton->input->buffer != nullptr) {
             // Reload PDF buffer
             VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -286,14 +288,32 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Reload PDF file
             image = VImage::pdfload(const_cast<char*>(baton->input->file.data()), option);
           }
-
           sharp::SetDensity(image, baton->input->density);
         }
       } else {
         if (inputImageType == sharp::ImageType::SVG && (image.width() > 32767 || image.height() > 32767)) {
-          throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");
+          throw std::runtime_error("Input SVG image exceeds 32767x32767 pixel limit");
         }
       }
+      if (baton->input->autoOrient) {
+        image = sharp::RemoveExifOrientation(image);
+      }
+      VImage gainMap;
+      int gainMapScaleFactor = 1;
+      if (sharp::HasGainMap(image)) {
+        if (baton->keepGainMap) {
+          gainMap = image.gainmap();
+          if (image.get_typeof("gainmap-scale-factor") == G_TYPE_INT) {
+            gainMapScaleFactor = image.get_int("gainmap-scale-factor");
+          }
+        } else if (baton->withGainMap) {
+          image = image.uhdr2scRGB();
+        }
+        image = sharp::RemoveGainMap(image);
+      } else {
+        baton->keepGainMap = false;
+        baton->withGainMap = false;
+      }
 
       // Any pre-shrinking may already have been done
       inputWidth = image.width();
@@ -333,7 +353,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         image.interpretation() != VIPS_INTERPRETATION_LABS &&
         image.interpretation() != VIPS_INTERPRETATION_GREY16 &&
         baton->colourspacePipeline != VIPS_INTERPRETATION_CMYK &&
-        !baton->input->ignoreIcc
+        !baton->input->ignoreIcc && !baton->withGainMap
       ) {
         // Convert to sRGB/P3 using embedded profile
         try {
@@ -354,7 +374,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Flatten image to remove alpha channel
-      if (baton->flatten && sharp::HasAlpha(image)) {
+      if (baton->flatten && image.has_alpha()) {
         image = sharp::Flatten(image, baton->flattenBackground);
       }
 
@@ -374,12 +394,12 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldSharpen = baton->sharpenSigma != 0.0;
       bool const shouldComposite = !baton->composite.empty();
 
-      if (shouldComposite && !sharp::HasAlpha(image)) {
+      if (shouldComposite && !image.has_alpha()) {
         image = sharp::EnsureAlpha(image, 1);
       }
 
       VipsBandFormat premultiplyFormat = image.format();
-      bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
+      bool const shouldPremultiplyAlpha = image.has_alpha() &&
         (shouldResize || shouldBlur || shouldConv || shouldSharpen);
 
       if (shouldPremultiplyAlpha) {
@@ -391,12 +411,16 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.resize(1.0 / hshrink, VImage::option()
           ->set("vscale", 1.0 / vshrink)
           ->set("kernel", baton->kernel));
+        if (baton->keepGainMap) {
+          gainMap = gainMap.resize(1.0 / hshrink, VImage::option()
+            ->set("vscale", 1.0 / vshrink)
+            ->set("kernel", baton->kernel));
+        }
       }
 
       image = sharp::StaySequential(image,
         autoRotation != VIPS_ANGLE_D0 ||
         baton->flip ||
-        autoFlip ||
         rotation != VIPS_ANGLE_D0);
       // Auto-rotate post-extract
       if (autoRotation != VIPS_ANGLE_D0) {
@@ -404,14 +428,23 @@ class PipelineWorker : public Napi::AsyncWorker {
           MultiPageUnsupported(nPages, "Rotate");
         }
         image = image.rot(autoRotation);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rot(autoRotation);
+        }
       }
       // Mirror vertically (up-down) about the x-axis
-      if (baton->flip || autoFlip) {
+      if (baton->flip) {
         image = image.flip(VIPS_DIRECTION_VERTICAL);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.flip(VIPS_DIRECTION_VERTICAL);
+        }
       }
       // Mirror horizontally (left-right) about the y-axis
-      if (baton->flop || autoFlop) {
+      if (baton->flop != autoFlop) {
         image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.flip(VIPS_DIRECTION_HORIZONTAL);
+        }
       }
       // Rotate post-extract 90-angle
       if (rotation != VIPS_ANGLE_D0) {
@@ -419,6 +452,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           MultiPageUnsupported(nPages, "Rotate");
         }
         image = image.rot(rotation);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rot(rotation);
+        }
       }
 
       // Join additional color channels to the image
@@ -454,12 +490,10 @@ class PipelineWorker : public Napi::AsyncWorker {
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground, shouldPremultiplyAlpha);
 
           // Embed
-          int left;
-          int top;
-          std::tie(left, top) = sharp::CalculateEmbedPosition(
+          const auto& [left, top] = sharp::CalculateEmbedPosition(
             inputWidth, inputHeight, baton->width, baton->height, baton->position);
-          int width = std::max(inputWidth, baton->width);
-          int height = std::max(inputHeight, baton->height);
+          const int width = std::max(inputWidth, baton->width);
+          const int height = std::max(inputHeight, baton->height);
 
           image = nPages > 1
             ? sharp::EmbedMultiPage(image,
@@ -467,6 +501,12 @@ class PipelineWorker : public Napi::AsyncWorker {
             : image.embed(left, top, width, height, VImage::option()
               ->set("extend", VIPS_EXTEND_BACKGROUND)
               ->set("background", background));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(left / gainMapScaleFactor, top / gainMapScaleFactor,
+              width / gainMapScaleFactor, height / gainMapScaleFactor, VImage::option()
+                ->set("extend", VIPS_EXTEND_BACKGROUND)
+                ->set("background", 0));
+          }
         } else if (baton->canvas == sharp::Canvas::CROP) {
           if (baton->width > inputWidth) {
             baton->width = inputWidth;
@@ -478,24 +518,26 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Crop
           if (baton->position < 9) {
             // Gravity-based crop
-            int left;
-            int top;
-
-            std::tie(left, top) = sharp::CalculateCrop(
+            const auto& [left, top] = sharp::CalculateCrop(
               inputWidth, inputHeight, baton->width, baton->height, baton->position);
-            int width = std::min(inputWidth, baton->width);
-            int height = std::min(inputHeight, baton->height);
+            const int width = std::min(inputWidth, baton->width);
+            const int height = std::min(inputHeight, baton->height);
 
             image = nPages > 1
               ? sharp::CropMultiPage(image,
                   left, top, width, height, nPages, &targetPageHeight)
               : image.extract_area(left, top, width, height);
+            if (baton->keepGainMap) {
+              gainMap = gainMap.extract_area(left / gainMapScaleFactor, top / gainMapScaleFactor,
+                width / gainMapScaleFactor, height / gainMapScaleFactor);
+            }
           } else {
             int attention_x;
             int attention_y;
 
             // Attention-based or Entropy-based crop
             MultiPageUnsupported(nPages, "Resize strategy");
+            KeepGainMapUnsupported(baton->keepGainMap, "Resize strategy");
             image = sharp::StaySequential(image);
             image = image.smartcrop(baton->width, baton->height, VImage::option()
               ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION)
@@ -513,12 +555,15 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Rotate post-extract non-90 angle
-      if (!baton->rotateBeforePreExtract && baton->rotationAngle != 0.0) {
+      if (!baton->rotateBefore && baton->rotationAngle != 0.0) {
         MultiPageUnsupported(nPages, "Rotate");
         image = sharp::StaySequential(image);
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, shouldPremultiplyAlpha);
         image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rotate(baton->rotationAngle, VImage::option()->set("background", 0));
+        }
       }
 
       // Post extraction
@@ -527,18 +572,23 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = sharp::CropMultiPage(image,
             baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost,
             nPages, &targetPageHeight);
-
           // heightPost is used in the info object, so update to reflect the number of pages
           baton->heightPost *= nPages;
         } else {
           image = image.extract_area(
             baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost);
+          if (baton->keepGainMap) {
+            gainMap = gainMap.extract_area(baton->leftOffsetPost / gainMapScaleFactor,
+              baton->topOffsetPost / gainMapScaleFactor, baton->widthPost / gainMapScaleFactor,
+              baton->heightPost / gainMapScaleFactor);
+          }
         }
       }
 
       // Affine transform
       if (!baton->affineMatrix.empty()) {
         MultiPageUnsupported(nPages, "Affine");
+        KeepGainMapUnsupported(baton->keepGainMap, "Affine");
         image = sharp::StaySequential(image);
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
@@ -569,6 +619,12 @@ class PipelineWorker : public Napi::AsyncWorker {
                 baton->extendWith, background, nPages, &targetPageHeight)
             : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
                 VImage::option()->set("extend", baton->extendWith)->set("background", background));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
+              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
+                ->set("extend", baton->extendWith)
+                ->set("background", 0));
+          }
         } else {
           std::vector<double> ignoredBackground(1);
           image = sharp::StaySequential(image);
@@ -578,6 +634,12 @@ class PipelineWorker : public Napi::AsyncWorker {
                 baton->extendWith, ignoredBackground, nPages, &targetPageHeight)
             : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
                 VImage::option()->set("extend", baton->extendWith));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
+              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
+                ->set("extend", baton->extendWith)
+                ->set("background", 0));
+          }
         }
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
@@ -591,9 +653,22 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::Threshold(image, baton->threshold, baton->thresholdGrayscale);
       }
 
+      // Dilate - must happen before blurring, due to the utility of dilating after thresholding
+      if (baton->dilateWidth != 0) {
+        image = sharp::Dilate(image, baton->dilateWidth);
+      }
+
+      // Erode - must happen before blurring, due to the utility of eroding after thresholding
+      if (baton->erodeWidth != 0) {
+        image = sharp::Erode(image, baton->erodeWidth);
+      }
+
       // Blur
       if (shouldBlur) {
         image = sharp::Blur(image, baton->blurSigma, baton->precision, baton->minAmpl);
+        if (baton->keepGainMap) {
+          gainMap = sharp::Blur(gainMap, baton->blurSigma, baton->precision, baton->minAmpl);
+        }
       }
 
       // Unflatten the image
@@ -603,6 +678,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Convolve
       if (shouldConv) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Convolve");
         image = sharp::Convolve(image,
           baton->convKernelWidth, baton->convKernelHeight,
           baton->convKernelScale, baton->convKernelOffset,
@@ -611,11 +687,13 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Recomb
       if (!baton->recombMatrix.empty()) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Recomb");
         image = sharp::Recomb(image, baton->recombMatrix);
       }
 
       // Modulate
       if (baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0 || baton->lightness != 0.0) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Modulate");
         image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue, baton->lightness);
       }
 
@@ -633,6 +711,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Composite
       if (shouldComposite) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Composite");
         std::vector<VImage> images = { image };
         std::vector<int> modes, xs, ys;
         for (Composite *composite : baton->composite) {
@@ -640,10 +719,28 @@ class PipelineWorker : public Napi::AsyncWorker {
           sharp::ImageType compositeImageType = sharp::ImageType::UNKNOWN;
           composite->input->access = access;
           std::tie(compositeImage, compositeImageType) = sharp::OpenInput(composite->input);
-          compositeImage = sharp::EnsureColourspace(compositeImage, baton->colourspacePipeline);
+
+          if (composite->input->autoOrient) {
+            // Respect EXIF Orientation
+            VipsAngle compositeAutoRotation = VIPS_ANGLE_D0;
+            bool compositeAutoFlop = false;
+            std::tie(compositeAutoRotation, compositeAutoFlop) =
+              CalculateExifRotationAndFlop(sharp::ExifOrientation(compositeImage));
+
+            compositeImage = sharp::RemoveExifOrientation(compositeImage);
+            compositeImage = sharp::StaySequential(compositeImage, compositeAutoRotation != VIPS_ANGLE_D0);
+
+            if (compositeAutoRotation != VIPS_ANGLE_D0) {
+              compositeImage = compositeImage.rot(compositeAutoRotation);
+            }
+            if (compositeAutoFlop) {
+              compositeImage = compositeImage.flip(VIPS_DIRECTION_HORIZONTAL);
+            }
+          }
+
           // Verify within current dimensions
           if (compositeImage.width() > image.width() || compositeImage.height() > image.height()) {
-            throw vips::VError("Image to composite must have same dimensions or smaller");
+            throw std::runtime_error("Image to composite must have same dimensions or smaller");
           }
           // Check if overlay is tiled
           if (composite->tile) {
@@ -681,11 +778,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             // gravity was used for extract_area, set it back to its default value of 0
             composite->gravity = 0;
           }
-          // Ensure image to composite is sRGB with unpremultiplied alpha
-          compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
-          if (!sharp::HasAlpha(compositeImage)) {
-            compositeImage = sharp::EnsureAlpha(compositeImage, 1);
-          }
+          // Ensure image to composite is with unpremultiplied alpha
+          compositeImage = sharp::EnsureAlpha(compositeImage, 1);
           if (composite->premultiplied) compositeImage = compositeImage.unpremultiply();
           // Calculate position
           int left;
@@ -709,7 +803,12 @@ class PipelineWorker : public Napi::AsyncWorker {
           xs.push_back(left);
           ys.push_back(top);
         }
-        image = VImage::composite(images, modes, VImage::option()->set("x", xs)->set("y", ys));
+        image = VImage::composite(images, modes, VImage::option()
+          ->set("compositing_space", baton->colourspacePipeline == VIPS_INTERPRETATION_LAST
+            ? VIPS_INTERPRETATION_sRGB
+            : baton->colourspacePipeline)
+          ->set("x", xs)
+          ->set("y", ys));
         image = sharp::RemoveGifPalette(image);
       }
 
@@ -725,18 +824,21 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Apply normalisation - stretch luminance to cover full dynamic range
       if (baton->normalise) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Normalise");
         image = sharp::StaySequential(image);
         image = sharp::Normalise(image, baton->normaliseLower, baton->normaliseUpper);
       }
 
       // Apply contrast limiting adaptive histogram equalization (CLAHE)
       if (baton->claheWidth != 0 && baton->claheHeight != 0) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Clahe");
         image = sharp::StaySequential(image);
         image = sharp::Clahe(image, baton->claheWidth, baton->claheHeight, baton->claheMaxSlope);
       }
 
       // Apply bitwise boolean operation between images
       if (baton->boolean != nullptr) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Boolean");
         VImage booleanImage;
         sharp::ImageType booleanImageType = sharp::ImageType::UNKNOWN;
         baton->boolean->access = access;
@@ -766,27 +868,22 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::EnsureAlpha(image, baton->ensureAlpha);
       }
 
-      // Convert image to sRGB, if not already
+      // Ensure output colour space
       if (sharp::Is16Bit(image.interpretation())) {
         image = image.cast(VIPS_FORMAT_USHORT);
       }
       if (image.interpretation() != baton->colourspace) {
-        // Convert colourspace, pass the current known interpretation so libvips doesn't have to guess
         image = image.colourspace(baton->colourspace, VImage::option()->set("source_space", image.interpretation()));
-        // Transform colours from embedded profile to output profile
-        if ((baton->keepMetadata & VIPS_FOREIGN_KEEP_ICC) && baton->colourspacePipeline != VIPS_INTERPRETATION_CMYK &&
-          baton->withIccProfile.empty() && sharp::HasProfile(image)) {
-          image = image.icc_transform(processingProfile, VImage::option()
-            ->set("embedded", true)
-            ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
-            ->set("intent", VIPS_INTENT_PERCEPTUAL));
+        if (inputProfile.first != nullptr && baton->withIccProfile.empty()) {
+          image = sharp::SetProfile(image, inputProfile);
         }
       }
 
       // Extract channel
       if (baton->extractChannel > -1) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Extract channel");
         if (baton->extractChannel >= image.bands()) {
-          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
+          if (baton->extractChannel == 3 && image.has_alpha()) {
             baton->extractChannel = image.bands() - 1;
           } else {
             (baton->err)
@@ -814,13 +911,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         } catch(...) {
           sharp::VipsWarningCallback(nullptr, G_LOG_LEVEL_WARNING, "Invalid profile", nullptr);
         }
-      } else if (baton->keepMetadata & VIPS_FOREIGN_KEEP_ICC) {
-        image = sharp::SetProfile(image, inputProfile);
       }
 
       // Negate the colours in the image
       if (baton->negate) {
         image = sharp::Negate(image, baton->negateAlpha);
+        if (baton->keepGainMap) {
+          gainMap = sharp::Negate(gainMap, false);
+        }
       }
 
       // Override EXIF Orientation tag
@@ -837,11 +935,16 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (!baton->withExifMerge) {
           image = sharp::RemoveExif(image);
         }
-        for (const auto& s : baton->withExif) {
-          image.set(s.first.data(), s.second.data());
+        for (const auto& [key, value] : baton->withExif) {
+          image.set(key.c_str(), value.c_str());
         }
       }
-
+      // XMP buffer
+      if ((baton->keepMetadata & VIPS_FOREIGN_KEEP_XMP) && !baton->withXmp.empty()) {
+        image = image.copy();
+        image.set(VIPS_META_XMP_NAME, nullptr,
+          const_cast<void*>(static_cast<void const*>(baton->withXmp.c_str())), baton->withXmp.size());
+      }
       // Number of channels used in output image
       baton->channels = image.bands();
       baton->width = image.width();
@@ -862,18 +965,27 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
-          VipsArea *area = reinterpret_cast<VipsArea*>(image.jpegsave_buffer(VImage::option()
-            ->set("keep", baton->keepMetadata)
-            ->set("Q", baton->jpegQuality)
-            ->set("interlace", baton->jpegProgressive)
-            ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_SUBSAMPLE_ON)
-            ->set("trellis_quant", baton->jpegTrellisQuantisation)
-            ->set("quant_table", baton->jpegQuantisationTable)
-            ->set("overshoot_deringing", baton->jpegOvershootDeringing)
-            ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", baton->jpegOptimiseCoding)));
+          VipsArea *area;
+          if (baton->keepGainMap) {
+            image = ReattachGainMap(image, gainMap, baton);
+            area = reinterpret_cast<VipsArea*>(image.uhdrsave_buffer(VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("gainmap_scale_factor", gainMapScaleFactor)));
+          } else {
+            area = reinterpret_cast<VipsArea*>(image.jpegsave_buffer(VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("interlace", baton->jpegProgressive)
+              ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
+                ? VIPS_FOREIGN_SUBSAMPLE_OFF
+                : VIPS_FOREIGN_SUBSAMPLE_ON)
+              ->set("trellis_quant", baton->jpegTrellisQuantisation)
+              ->set("quant_table", baton->jpegQuantisationTable)
+              ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+              ->set("optimize_scans", baton->jpegOptimiseScans)
+              ->set("optimize_coding", baton->jpegOptimiseCoding)));
+          }
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -929,10 +1041,12 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("lossless", baton->webpLossless)
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
+            ->set("smart_deblock", baton->webpSmartDeblock)
             ->set("preset", baton->webpPreset)
             ->set("effort", baton->webpEffort)
             ->set("min_size", baton->webpMinSize)
             ->set("mixed", baton->webpMixed)
+            ->set("exact", baton->webpExact)
             ->set("alpha_q", baton->webpAlphaQuality)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -951,6 +1065,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("interlace", baton->gifProgressive)
             ->set("interframe_maxerror", baton->gifInterFrameMaxError)
             ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
+            ->set("keep_duplicate_frames", baton->gifKeepDuplicateFrames)
             ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -973,6 +1088,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->tiffQuality)
             ->set("bitdepth", baton->tiffBitdepth)
             ->set("compression", baton->tiffCompression)
+            ->set("bigtiff", baton->tiffBigtiff)
             ->set("miniswhite", baton->tiffMiniswhite)
             ->set("predictor", baton->tiffPredictor)
             ->set("pyramid", baton->tiffPyramid)
@@ -991,13 +1107,14 @@ class PipelineWorker : public Napi::AsyncWorker {
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::HEIF);
-          image = sharp::RemoveAnimationProperties(image).cast(VIPS_FORMAT_UCHAR);
+          image = sharp::RemoveAnimationProperties(image);
           VipsArea *area = reinterpret_cast<VipsArea*>(image.heifsave_buffer(VImage::option()
             ->set("keep", baton->keepMetadata)
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
             ->set("effort", baton->heifEffort)
             ->set("bitdepth", baton->heifBitdepth)
+            ->set("tune", baton->heifTune.c_str())
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless)));
@@ -1009,7 +1126,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         } else if (baton->formatOut == "dz") {
           // Write DZ to buffer
           baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_ZIP;
-          if (!sharp::HasAlpha(image)) {
+          if (!image.has_alpha()) {
             baton->tileBackground.pop_back();
           }
           image = sharp::StaySequential(image, baton->tileAngle != 0);
@@ -1050,19 +1167,19 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Get raw image data
           baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));
           if (baton->bufferOut == nullptr) {
-            (baton->err).append("Could not allocate enough memory for raw output");
-            return Error();
+            throw std::runtime_error("Could not allocate enough memory for raw output");
           }
           baton->formatOut = "raw";
         } else {
           // Unsupported output format
-          (baton->err).append("Unsupported output format ");
+          auto unsupported = std::string("Unsupported output format ");
           if (baton->formatOut == "input") {
-            (baton->err).append(ImageTypeId(inputImageType));
+            unsupported.append("when trying to match input format of ");
+            unsupported.append(ImageTypeId(inputImageType));
           } else {
-            (baton->err).append(baton->formatOut);
+            unsupported.append(baton->formatOut);
           }
-          return Error();
+          throw std::runtime_error(unsupported);
         }
       } else {
         // File output
@@ -1085,18 +1202,26 @@ class PipelineWorker : public Napi::AsyncWorker {
           (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to file
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
-          image.jpegsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
-            ->set("keep", baton->keepMetadata)
-            ->set("Q", baton->jpegQuality)
-            ->set("interlace", baton->jpegProgressive)
-            ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_SUBSAMPLE_ON)
-            ->set("trellis_quant", baton->jpegTrellisQuantisation)
-            ->set("quant_table", baton->jpegQuantisationTable)
-            ->set("overshoot_deringing", baton->jpegOvershootDeringing)
-            ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", baton->jpegOptimiseCoding));
+          if (baton->keepGainMap) {
+            image = ReattachGainMap(image, gainMap, baton);
+            image.uhdrsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("gainmap_scale_factor", gainMapScaleFactor));
+          } else {
+            image.jpegsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("interlace", baton->jpegProgressive)
+              ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
+                ? VIPS_FOREIGN_SUBSAMPLE_OFF
+                : VIPS_FOREIGN_SUBSAMPLE_ON)
+              ->set("trellis_quant", baton->jpegTrellisQuantisation)
+              ->set("quant_table", baton->jpegQuantisationTable)
+              ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+              ->set("optimize_scans", baton->jpegOptimiseScans)
+              ->set("optimize_coding", baton->jpegOptimiseCoding));
+          }
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
         } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
@@ -1136,10 +1261,12 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("lossless", baton->webpLossless)
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
+            ->set("smart_deblock", baton->webpSmartDeblock)
             ->set("preset", baton->webpPreset)
             ->set("effort", baton->webpEffort)
             ->set("min_size", baton->webpMinSize)
             ->set("mixed", baton->webpMixed)
+            ->set("exact", baton->webpExact)
             ->set("alpha_q", baton->webpAlphaQuality));
           baton->formatOut = "webp";
         } else if (baton->formatOut == "gif" || (mightMatchInput && isGif) ||
@@ -1152,6 +1279,9 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("effort", baton->gifEffort)
             ->set("reuse", baton->gifReuse)
             ->set("interlace", baton->gifProgressive)
+            ->set("interframe_maxerror", baton->gifInterFrameMaxError)
+            ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
+            ->set("keep_duplicate_frames", baton->gifKeepDuplicateFrames)
             ->set("dither", baton->gifDither));
           baton->formatOut = "gif";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
@@ -1170,6 +1300,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->tiffQuality)
             ->set("bitdepth", baton->tiffBitdepth)
             ->set("compression", baton->tiffCompression)
+            ->set("bigtiff", baton->tiffBigtiff)
             ->set("miniswhite", baton->tiffMiniswhite)
             ->set("predictor", baton->tiffPredictor)
             ->set("pyramid", baton->tiffPyramid)
@@ -1184,13 +1315,14 @@ class PipelineWorker : public Napi::AsyncWorker {
           (willMatchInput && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to file
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::HEIF);
-          image = sharp::RemoveAnimationProperties(image).cast(VIPS_FORMAT_UCHAR);
+          image = sharp::RemoveAnimationProperties(image);
           image.heifsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("keep", baton->keepMetadata)
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
             ->set("effort", baton->heifEffort)
             ->set("bitdepth", baton->heifBitdepth)
+            ->set("tune", baton->heifTune.c_str())
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless));
@@ -1211,7 +1343,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (isDzZip) {
             baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_ZIP;
           }
-          if (!sharp::HasAlpha(image)) {
+          if (!image.has_alpha()) {
             baton->tileBackground.pop_back();
           }
           image = sharp::StaySequential(image, baton->tileAngle != 0);
@@ -1230,12 +1362,17 @@ class PipelineWorker : public Napi::AsyncWorker {
           return Error();
         }
       }
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       char const *what = err.what();
       if (what && what[0]) {
         (baton->err).append(what);
       } else {
-        (baton->err).append("Unknown error");
+        if (baton->input->failOn == VIPS_FAIL_ON_WARNING) {
+          (baton->err).append("Warning treated as error due to failOn setting");
+          baton->errUseWarning = true;
+        } else {
+          (baton->err).append("Unknown error");
+        }
       }
     }
     // Clean up libvips' per-request data and threads
@@ -1250,10 +1387,13 @@ class PipelineWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
+      if (baton->errUseWarning) {
+        (baton->err).append("\n").append(warning);
+      } else {
+        debuglog.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
+      }
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       int width = baton->width;
       int height = baton->height;
@@ -1296,22 +1436,33 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       if (baton->bufferOutLength > 0) {
-        // Add buffer size to info
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
-        // Pass ownership of output data to Buffer instance
-        Napi::Buffer<char> data = Napi::Buffer<char>::NewOrCopy(env, static_cast<char*>(baton->bufferOut),
-          baton->bufferOutLength, sharp::FreeCallback);
-        Callback().Call(Receiver().Value(), { env.Null(), data, info });
+        if (baton->typedArrayOut) {
+          // ECMAScript ArrayBuffer with Uint8Array view
+          Napi::TypedArrayOf<uint8_t> data = Napi::Buffer<char>::Copy(env,
+            static_cast<char*>(baton->bufferOut), baton->bufferOutLength);
+          sharp::FreeCallback(static_cast<char*>(baton->bufferOut), nullptr);
+          Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), data, info });
+        } else {
+          // Node.js Buffer
+          Napi::Buffer<char> data = Napi::Buffer<char>::NewOrCopy(env, static_cast<char*>(baton->bufferOut),
+            baton->bufferOutLength, sharp::FreeCallback);
+          Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), data, info });
+        }
       } else {
         // Add file size to info
-        struct STAT64_STRUCT st;
-        if (STAT64_FUNCTION(baton->fileOut.data(), &st) == 0) {
-          info.Set("size", static_cast<uint32_t>(st.st_size));
+        if (baton->formatOut != "dz" || sharp::IsDzZip(baton->fileOut)) {
+          try {
+            uint32_t const size = static_cast<uint32_t>(
+              std::filesystem::file_size(std::filesystem::u8path(baton->fileOut)));
+            info.Set("size", size);
+          } catch (...) {}
         }
-        Callback().Call(Receiver().Value(), { env.Null(), info });
+        Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
       }
     } else {
-      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(),
+        { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     // Delete baton
@@ -1324,12 +1475,15 @@ class PipelineWorker : public Napi::AsyncWorker {
     for (sharp::InputDescriptor *input : baton->joinChannelIn) {
       delete input;
     }
+    for (sharp::InputDescriptor *input : baton->join) {
+      delete input;
+    }
     delete baton;
 
     // Decrement processing task counter
     sharp::counterProcess--;
     Napi::Number queueLength = Napi::Number::New(env, static_cast<int>(sharp::counterQueue));
-    queueListener.Call(Receiver().Value(), { queueLength });
+    queueListener.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { queueLength });
   }
 
  private:
@@ -1339,7 +1493,13 @@ class PipelineWorker : public Napi::AsyncWorker {
 
   void MultiPageUnsupported(int const pages, std::string op) {
     if (pages > 1) {
-      throw vips::VError(op + " is not supported for multi-page images");
+      throw std::runtime_error(op + " is not supported for multi-page images");
+    }
+  }
+
+  void KeepGainMapUnsupported(bool const keepGainMap, std::string op) {
+    if (keepGainMap) {
+      throw std::runtime_error(op + " is not supported when keeping gain maps");
     }
   }
 
@@ -1347,21 +1507,20 @@ class PipelineWorker : public Napi::AsyncWorker {
     Calculate the angle of rotation and need-to-flip for the given Exif orientation
     By default, returns zero, i.e. no rotation.
   */
-  std::tuple<VipsAngle, bool, bool>
-  CalculateExifRotationAndFlip(int const exifOrientation) {
+  std::tuple<VipsAngle, bool>
+  CalculateExifRotationAndFlop(int const exifOrientation) {
     VipsAngle rotate = VIPS_ANGLE_D0;
-    bool flip = false;
     bool flop = false;
     switch (exifOrientation) {
       case 6: rotate = VIPS_ANGLE_D90; break;
       case 3: rotate = VIPS_ANGLE_D180; break;
       case 8: rotate = VIPS_ANGLE_D270; break;
-      case 2: flop = true; break;  // flop 1
-      case 7: flip = true; rotate = VIPS_ANGLE_D90; break;  // flip 6
-      case 4: flop = true; rotate = VIPS_ANGLE_D180; break;  // flop 3
-      case 5: flip = true; rotate = VIPS_ANGLE_D270; break;  // flip 8
+      case 2: flop = true; break;
+      case 7: flop = true; rotate = VIPS_ANGLE_D270; break;
+      case 4: flop = true; rotate = VIPS_ANGLE_D180; break;
+      case 5: flop = true; rotate = VIPS_ANGLE_D90; break;
     }
-    return std::make_tuple(rotate, flip, flop);
+    return std::make_tuple(rotate, flop);
   }
 
   /*
@@ -1389,11 +1548,11 @@ class PipelineWorker : public Napi::AsyncWorker {
   std::string
   AssembleSuffixString(std::string extname, std::vector<std::pair<std::string, std::string>> options) {
     std::string argument;
-    for (auto const &option : options) {
+    for (const auto& [key, value] : options) {
       if (!argument.empty()) {
         argument += ",";
       }
-      argument += option.first + "=" + option.second;
+      argument += key + "=" + value;
     }
     return extname + "[" + argument + "]";
   }
@@ -1419,9 +1578,11 @@ class PipelineWorker : public Napi::AsyncWorker {
         {"lossless", baton->webpLossless ? "true" : "false"},
         {"near_lossless", baton->webpNearLossless ? "true" : "false"},
         {"smart_subsample", baton->webpSmartSubsample ? "true" : "false"},
+        {"smart_deblock", baton->webpSmartDeblock ? "true" : "false"},
         {"preset", vips_enum_nick(VIPS_TYPE_FOREIGN_WEBP_PRESET, baton->webpPreset)},
         {"min_size", baton->webpMinSize ? "true" : "false"},
         {"mixed", baton->webpMixed ? "true" : "false"},
+        {"exact", baton->webpExact ? "true" : "false"},
         {"effort", std::to_string(baton->webpEffort)}
       };
       suffix = AssembleSuffixString(".webp", options);
@@ -1460,6 +1621,21 @@ class PipelineWorker : public Napi::AsyncWorker {
     return options;
   }
 
+  VImage ReattachGainMap(VImage image, VImage gainMap, PipelineBaton *baton) {
+    VipsArea *gainMapJpeg = reinterpret_cast<VipsArea*>(gainMap.jpegsave_buffer(VImage::option()
+      ->set("keep", FALSE)
+      ->set("Q", baton->jpegQuality)
+      ->set("subsample_mode", VIPS_FOREIGN_SUBSAMPLE_OFF)
+      ->set("trellis_quant", baton->jpegTrellisQuantisation)
+      ->set("quant_table", baton->jpegQuantisationTable)
+      ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+      ->set("optimize_coding", baton->jpegOptimiseCoding)));
+    image = image.copy();
+    image.set("gainmap-data", reinterpret_cast<VipsCallbackFn>(vips_area_free_cb),
+      gainMapJpeg->data, gainMapJpeg->length);
+    return image;
+  }
+
   /*
     Clear all thread-local data.
   */
@@ -1480,6 +1656,14 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
 
   // Input
   baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+  // Join images together
+  if (sharp::HasAttr(options, "join")) {
+    Napi::Array join = options.Get("join").As<Napi::Array>();
+    for (unsigned int i = 0; i < join.Length(); i++) {
+      baton->join.push_back(
+        sharp::CreateInputDescriptor(join.Get(i).As<Napi::Object>()));
+    }
+  }
   // Extract image options
   baton->topOffsetPre = sharp::AttrAsInt32(options, "topOffsetPre");
   baton->leftOffsetPre = sharp::AttrAsInt32(options, "leftOffsetPre");
@@ -1560,10 +1744,13 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->trimBackground = sharp::AttrAsVectorOfDouble(options, "trimBackground");
   baton->trimThreshold = sharp::AttrAsDouble(options, "trimThreshold");
   baton->trimLineArt = sharp::AttrAsBool(options, "trimLineArt");
+  baton->trimMargin = sharp::AttrAsUint32(options, "trimMargin");
   baton->gamma = sharp::AttrAsDouble(options, "gamma");
   baton->gammaOut = sharp::AttrAsDouble(options, "gammaOut");
   baton->linearA = sharp::AttrAsVectorOfDouble(options, "linearA");
   baton->linearB = sharp::AttrAsVectorOfDouble(options, "linearB");
+  baton->dilateWidth = sharp::AttrAsUint32(options, "dilateWidth");
+  baton->erodeWidth = sharp::AttrAsUint32(options, "erodeWidth");
   baton->greyscale = sharp::AttrAsBool(options, "greyscale");
   baton->normalise = sharp::AttrAsBool(options, "normalise");
   baton->normaliseLower = sharp::AttrAsUint32(options, "normaliseLower");
@@ -1572,11 +1759,11 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->claheWidth = sharp::AttrAsUint32(options, "claheWidth");
   baton->claheHeight = sharp::AttrAsUint32(options, "claheHeight");
   baton->claheMaxSlope = sharp::AttrAsUint32(options, "claheMaxSlope");
-  baton->useExifOrientation = sharp::AttrAsBool(options, "useExifOrientation");
   baton->angle = sharp::AttrAsInt32(options, "angle");
   baton->rotationAngle = sharp::AttrAsDouble(options, "rotationAngle");
   baton->rotationBackground = sharp::AttrAsVectorOfDouble(options, "rotationBackground");
-  baton->rotateBeforePreExtract = sharp::AttrAsBool(options, "rotateBeforePreExtract");
+  baton->rotateBefore = sharp::AttrAsBool(options, "rotateBefore");
+  baton->orientBefore = sharp::AttrAsBool(options, "orientBefore");
   baton->flip = sharp::AttrAsBool(options, "flip");
   baton->flop = sharp::AttrAsBool(options, "flop");
   baton->extendTop = sharp::AttrAsInt32(options, "extendTop");
@@ -1635,6 +1822,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   // Output
   baton->formatOut = sharp::AttrAsStr(options, "formatOut");
   baton->fileOut = sharp::AttrAsStr(options, "fileOut");
+  baton->typedArrayOut = sharp::AttrAsBool(options, "typedArrayOut");
   baton->keepMetadata = sharp::AttrAsUint32(options, "keepMetadata");
   baton->withMetadataOrientation = sharp::AttrAsUint32(options, "withMetadataOrientation");
   baton->withMetadataDensity = sharp::AttrAsDouble(options, "withMetadataDensity");
@@ -1648,7 +1836,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     }
   }
   baton->withExifMerge = sharp::AttrAsBool(options, "withExifMerge");
+  baton->withXmp = sharp::AttrAsStr(options, "withXmp");
+  baton->keepGainMap = sharp::AttrAsBool(options, "keepGainMap");
+  baton->withGainMap = sharp::AttrAsBool(options, "withGainMap");
   baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
+  baton->loop = sharp::AttrAsUint32(options, "loop");
+  baton->delay = sharp::AttrAsInt32Vector(options, "delay");
   // Format-specific
   baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
   baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");
@@ -1676,18 +1869,22 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->webpLossless = sharp::AttrAsBool(options, "webpLossless");
   baton->webpNearLossless = sharp::AttrAsBool(options, "webpNearLossless");
   baton->webpSmartSubsample = sharp::AttrAsBool(options, "webpSmartSubsample");
+  baton->webpSmartDeblock = sharp::AttrAsBool(options, "webpSmartDeblock");
   baton->webpPreset = sharp::AttrAsEnum<VipsForeignWebpPreset>(options, "webpPreset", VIPS_TYPE_FOREIGN_WEBP_PRESET);
   baton->webpEffort = sharp::AttrAsUint32(options, "webpEffort");
   baton->webpMinSize = sharp::AttrAsBool(options, "webpMinSize");
   baton->webpMixed = sharp::AttrAsBool(options, "webpMixed");
+  baton->webpExact = sharp::AttrAsBool(options, "webpExact");
   baton->gifBitdepth = sharp::AttrAsUint32(options, "gifBitdepth");
   baton->gifEffort = sharp::AttrAsUint32(options, "gifEffort");
   baton->gifDither = sharp::AttrAsDouble(options, "gifDither");
   baton->gifInterFrameMaxError = sharp::AttrAsDouble(options, "gifInterFrameMaxError");
   baton->gifInterPaletteMaxError = sharp::AttrAsDouble(options, "gifInterPaletteMaxError");
+  baton->gifKeepDuplicateFrames = sharp::AttrAsBool(options, "gifKeepDuplicateFrames");
   baton->gifReuse = sharp::AttrAsBool(options, "gifReuse");
   baton->gifProgressive = sharp::AttrAsBool(options, "gifProgressive");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
+  baton->tiffBigtiff = sharp::AttrAsBool(options, "tiffBigtiff");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
   baton->tiffMiniswhite = sharp::AttrAsBool(options, "tiffMiniswhite");
   baton->tiffBitdepth = sharp::AttrAsUint32(options, "tiffBitdepth");
@@ -1712,18 +1909,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->heifEffort = sharp::AttrAsUint32(options, "heifEffort");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
   baton->heifBitdepth = sharp::AttrAsUint32(options, "heifBitdepth");
+  baton->heifTune = sharp::AttrAsStr(options, "heifTune");
   baton->jxlDistance = sharp::AttrAsDouble(options, "jxlDistance");
   baton->jxlDecodingTier = sharp::AttrAsUint32(options, "jxlDecodingTier");
   baton->jxlEffort = sharp::AttrAsUint32(options, "jxlEffort");
   baton->jxlLossless = sharp::AttrAsBool(options, "jxlLossless");
   baton->rawDepth = sharp::AttrAsEnum<VipsBandFormat>(options, "rawDepth", VIPS_TYPE_BAND_FORMAT);
-  // Animated output properties
-  if (sharp::HasAttr(options, "loop")) {
-    baton->loop = sharp::AttrAsUint32(options, "loop");
-  }
-  if (sharp::HasAttr(options, "delay")) {
-    baton->delay = sharp::AttrAsInt32Vector(options, "delay");
-  }
   baton->tileSize = sharp::AttrAsUint32(options, "tileSize");
   baton->tileOverlap = sharp::AttrAsUint32(options, "tileOverlap");
   baton->tileAngle = sharp::AttrAsInt32(options, "tileAngle");
@@ -1752,7 +1943,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
 
   // Increment queued task counter
   Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<int>(++sharp::counterQueue));
-  queueListener.Call(info.This(), { queueLength });
+  queueListener.SHARP_CALLBACK_FN_NAME(info.This(), { queueLength });
 
   return info.Env().Undefined();
 }