@revizly/sharp 0.33.3-revizly4 → 0.33.4-revizly1

package/install/check.js

@@ -10,8 +10,8 @@ try {
     log(msg);
     log('Attempting to build from source via node-gyp');
     try {
-      require('node-addon-api');
-      log('Found node-addon-api');
+      const addonApi = require('node-addon-api');
+      log(`Found node-addon-api ${addonApi.version || ''}`);
     } catch (err) {
       log('Please add node-addon-api to your dependencies');
       return;

package/lib/colour.js

@@ -71,8 +71,6 @@ function grayscale (grayscale) {
  * All operations will use this colourspace before converting to the output colourspace,
  * as defined by {@link #tocolourspace|toColourspace}.
  *
- * This feature is experimental and has not yet been fully-tested with all operations.
- *
  * @since 0.29.0
  *
  * @example

package/lib/index.d.ts

@@ -1479,6 +1479,14 @@ declare namespace sharp {
         tile?: boolean | undefined;
         /** Set to true to avoid premultipling the image below. Equivalent to the --premultiplied vips option. */
         premultiplied?: boolean | undefined;
+        /** number representing the DPI for vector overlay image. (optional, default 72)*/
+        density?: number | undefined;
+        /** Set to true to read all frames/pages of an animated image. (optional, default false) */
+        animated?: boolean | undefined;
+        /** see sharp() constructor, (optional, default 'warning') */
+        failOn?: FailOnOptions | undefined;
+        /** see sharp() constructor, (optional, default 268402689) */
+        limitInputPixels?: number | boolean | undefined;
     }
 
     interface TileOptions {

package/lib/input.js

@@ -296,17 +296,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.width)) {
-          if (is.number(inputOptions.text.width)) {
+          if (is.integer(inputOptions.text.width) && inputOptions.text.width > 0) {
             inputDescriptor.textWidth = inputOptions.text.width;
           } else {
-            throw is.invalidParameterError('text.textWidth', 'number', inputOptions.text.width);
+            throw is.invalidParameterError('text.width', 'positive integer', inputOptions.text.width);
           }
         }
         if (is.defined(inputOptions.text.height)) {
-          if (is.number(inputOptions.text.height)) {
+          if (is.integer(inputOptions.text.height) && inputOptions.text.height > 0) {
             inputDescriptor.textHeight = inputOptions.text.height;
           } else {
-            throw is.invalidParameterError('text.height', 'number', inputOptions.text.height);
+            throw is.invalidParameterError('text.height', 'positive integer', inputOptions.text.height);
           }
         }
         if (is.defined(inputOptions.text.align)) {
@@ -324,10 +324,10 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.dpi)) {
-          if (is.number(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 100000)) {
+          if (is.integer(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 1000000)) {
             inputDescriptor.textDpi = inputOptions.text.dpi;
           } else {
-            throw is.invalidParameterError('text.dpi', 'number between 1 and 100000', inputOptions.text.dpi);
+            throw is.invalidParameterError('text.dpi', 'integer between 1 and 1000000', inputOptions.text.dpi);
           }
         }
         if (is.defined(inputOptions.text.rgba)) {
@@ -338,10 +338,10 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.spacing)) {
-          if (is.number(inputOptions.text.spacing)) {
+          if (is.integer(inputOptions.text.spacing) && is.inRange(inputOptions.text.spacing, -1000000, 1000000)) {
             inputDescriptor.textSpacing = inputOptions.text.spacing;
           } else {
-            throw is.invalidParameterError('text.spacing', 'number', inputOptions.text.spacing);
+            throw is.invalidParameterError('text.spacing', 'integer between -1000000 and 1000000', inputOptions.text.spacing);
           }
         }
         if (is.defined(inputOptions.text.wrap)) {

package/lib/libvips.js

@@ -162,15 +162,21 @@ const pkgConfigPath = () => {
   }
 };
 
+const skipSearch = (status, reason) => {
+  log(`Detected ${reason}, skipping search for globally-installed libvips`);
+  return status;
+};
+
 const useGlobalLibvips = () => {
   if (Boolean(process.env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
-    log('Detected SHARP_IGNORE_GLOBAL_LIBVIPS, skipping search for globally-installed libvips');
-    return false;
+    return skipSearch(false, 'SHARP_IGNORE_GLOBAL_LIBVIPS');
+  }
+  if (Boolean(process.env.SHARP_FORCE_GLOBAL_LIBVIPS) === true) {
+    return skipSearch(true, 'SHARP_FORCE_GLOBAL_LIBVIPS');
   }
   /* istanbul ignore next */
   if (isRosetta()) {
-    log('Detected Rosetta, skipping search for globally-installed libvips');
-    return false;
+    return skipSearch(false, 'Rosetta');
   }
   const globalVipsVersion = globalLibvipsVersion();
   return !!globalVipsVersion && /* istanbul ignore next */

package/lib/resize.js

@@ -68,6 +68,7 @@ const strategy = {
  */
 const kernel = {
   nearest: 'nearest',
+  linear: 'linear',
   cubic: 'cubic',
   mitchell: 'mitchell',
   lanczos2: 'lanczos2',
@@ -135,18 +136,22 @@ function isResizeExpected (options) {
  *
  * 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
+ * The strategy-based approach initially 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:
+ * Possible downsizing kernels are:
  * - `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
+ * - `linear`: Use a [triangle filter](https://en.wikipedia.org/wiki/Triangular_function).
  * - `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).
  *
+ * When upsampling, these kernels map to `nearest`, `linear` and `cubic` interpolators.
+ * Downsampling kernels without a matching upsampling interpolator map to `cubic`.
+ *
  * Only one resize can occur per pipeline.
  * Previous calls to `resize` in the same pipeline will be ignored.
  *
@@ -239,7 +244,7 @@ function isResizeExpected (options) {
  * @param {String} [options.fit='cover'] - How the image should be resized/cropped to fit the target dimension(s), one of `cover`, `contain`, `fill`, `inside` or `outside`.
  * @param {String} [options.position='centre'] - A 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. Use the `fastShrinkOnLoad` option to control kernel vs shrink-on-load.
+ * @param {String} [options.kernel='lanczos3'] - The kernel to use for image reduction and the inferred interpolator to use for upsampling. Use the `fastShrinkOnLoad` option to control kernel vs shrink-on-load.
  * @param {Boolean} [options.withoutEnlargement=false] - Do not scale up if the width *or* height are already less than the target dimensions, equivalent to GraphicsMagick's `>` geometry option. This may result in output dimensions smaller than the target dimensions.
  * @param {Boolean} [options.withoutReduction=false] - Do not scale down if the width *or* height are already greater than the target dimensions, equivalent to GraphicsMagick's `<` geometry option. This may still result in a crop to reach the target dimensions.
  * @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 or round-down of an auto-scaled dimension.

package/lib/utility.js

@@ -153,6 +153,9 @@ function concurrency (concurrency) {
 if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
+} else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {
+  // Reduce default concurrency when musl thread over-subscription detected
+  sharp.concurrency(require('node:os').availableParallelism());
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@revizly/sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.33.3-revizly4",
+  "version": "0.33.4-revizly1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",
   "contributors": [
@@ -82,7 +82,7 @@
     "Joris Dugué <zaruike10@gmail.com>",
     "Chris Banks <christopher.bradley.banks@gmail.com>",
     "Ompal Singh <ompal.hitm09@gmail.com>",
-    "Brodan <christopher.hranj@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>",
@@ -141,30 +141,30 @@
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
-    "@revizly/sharp-libvips-linux-arm64": "1.0.3",
-    "@revizly/sharp-libvips-linux-x64": "1.0.3",
-    "@revizly/sharp-linux-arm64": "0.33.2-revizly8",
-    "@revizly/sharp-linux-x64": "0.33.2-revizly8"
+    "@revizly/sharp-libvips-linux-arm64": "1.0.5",
+    "@revizly/sharp-libvips-linux-x64": "1.0.5",
+    "@revizly/sharp-linux-arm64": "0.33.3-revizly1",
+    "@revizly/sharp-linux-x64": "0.33.3-revizly1"
   },
   "devDependencies": {
-    "@emnapi/runtime": "^1.1.0",
-    "@revizly/sharp-libvips-dev": "1.0.3",
+    "@emnapi/runtime": "^1.1.1",
+    "@revizly/sharp-libvips-dev": "1.0.5",
     "@types/node": "*",
     "async": "^3.2.5",
     "cc": "^3.0.1",
-    "emnapi": "^1.1.0",
+    "emnapi": "^1.1.1",
     "exif-reader": "^2.0.1",
     "extract-zip": "^2.0.1",
     "icc": "^3.0.0",
     "jsdoc-to-markdown": "^8.0.1",
     "license-checker": "^25.0.1",
-    "mocha": "^10.3.0",
+    "mocha": "^10.4.0",
     "node-addon-api": "^8.0.0",
     "nyc": "^15.1.0",
-    "prebuild": "^13.0.0",
+    "prebuild": "^13.0.1",
     "semistandard": "^17.0.0",
-    "tar-fs": "^3.0.5",
-    "tsd": "^0.30.7"
+    "tar-fs": "^3.0.6",
+    "tsd": "^0.31.0"
   },
   "license": "Apache-2.0",
   "engines": {

package/src/common.cc

@@ -75,7 +75,7 @@ namespace sharp {
       Napi::Buffer<char> buffer = input.Get("buffer").As<Napi::Buffer<char>>();
       descriptor->bufferLength = buffer.Length();
       descriptor->buffer = buffer.Data();
-      descriptor->isBuffer = TRUE;
+      descriptor->isBuffer = true;
     }
     descriptor->failOn = AttrAsEnum<VipsFailOn>(input, "failOn", VIPS_TYPE_FAIL_ON);
     // Density for vector-based input
@@ -384,7 +384,7 @@ namespace sharp {
               ->set("access", descriptor->access)
               ->set("fail_on", descriptor->failOn);
             if (descriptor->unlimited && ImageTypeSupportsUnlimited(imageType)) {
-              option->set("unlimited", TRUE);
+              option->set("unlimited", true);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
               option->set("dpi", descriptor->density);
@@ -488,7 +488,7 @@ namespace sharp {
               ->set("access", descriptor->access)
               ->set("fail_on", descriptor->failOn);
             if (descriptor->unlimited && ImageTypeSupportsUnlimited(imageType)) {
-              option->set("unlimited", TRUE);
+              option->set("unlimited", true);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
               option->set("dpi", descriptor->density);
@@ -768,7 +768,7 @@ namespace sharp {
         int *timeout = VIPS_NEW(im, int);
         *timeout = seconds;
         g_signal_connect(im, "eval", G_CALLBACK(VipsProgressCallBack), timeout);
-        vips_image_set_progress(im, TRUE);
+        vips_image_set_progress(im, true);
       }
     }
   }
@@ -778,7 +778,7 @@ namespace sharp {
   */
   void VipsProgressCallBack(VipsImage *im, VipsProgress *progress, int *timeout) {
     if (*timeout > 0 && progress->run >= *timeout) {
-      vips_image_set_kill(im, TRUE);
+      vips_image_set_kill(im, true);
       vips_error("timeout", "%d%% complete", progress->percent);
       *timeout = 0;
     }
@@ -1081,9 +1081,10 @@ namespace sharp {
   /*
     Ensure decoding remains sequential.
   */
-  VImage StaySequential(VImage image, VipsAccess access, bool condition) {
-    if (access == VIPS_ACCESS_SEQUENTIAL && condition) {
-      return image.copy_memory();
+  VImage StaySequential(VImage image, bool condition) {
+    if (vips_image_is_sequential(image.get_image()) && condition) {
+      image = image.copy_memory().copy();
+      image.remove(VIPS_META_SEQUENTIAL);
     }
     return image;
   }

package/src/common.h

@@ -79,12 +79,12 @@ namespace sharp {
       buffer(nullptr),
       failOn(VIPS_FAIL_ON_WARNING),
       limitInputPixels(0x3FFF * 0x3FFF),
-      unlimited(FALSE),
+      unlimited(false),
       access(VIPS_ACCESS_RANDOM),
       bufferLength(0),
-      isBuffer(FALSE),
+      isBuffer(false),
       density(72.0),
-      ignoreIcc(FALSE),
+      ignoreIcc(false),
       rawDepth(VIPS_FORMAT_UCHAR),
       rawChannels(0),
       rawWidth(0),
@@ -103,9 +103,9 @@ namespace sharp {
       textWidth(0),
       textHeight(0),
       textAlign(VIPS_ALIGN_LOW),
-      textJustify(FALSE),
+      textJustify(false),
       textDpi(72),
-      textRgba(FALSE),
+      textRgba(false),
       textSpacing(0),
       textWrap(VIPS_TEXT_WRAP_WORD),
       textAutofitDpi(0) {}
@@ -386,7 +386,7 @@ namespace sharp {
   /*
     Ensure decoding remains sequential.
   */
-  VImage StaySequential(VImage image, VipsAccess access, bool condition = TRUE);
+  VImage StaySequential(VImage image, bool condition = true);
 
 }  // namespace sharp
 

package/src/operations.cc

@@ -155,7 +155,7 @@ namespace sharp {
       return image.conv(blur);
     } else {
       // Slower, accurate Gaussian blur
-      return StaySequential(image, VIPS_ACCESS_SEQUENTIAL).gaussblur(sigma);
+      return StaySequential(image).gaussblur(sigma);
     }
   }
 
@@ -386,7 +386,7 @@ namespace sharp {
       pages.reserve(nPages);
 
       // Split the image into cropped frames
-      image = StaySequential(image, VIPS_ACCESS_SEQUENTIAL);
+      image = StaySequential(image);
       for (int i = 0; i < nPages; i++) {
         pages.push_back(
           image.extract_area(left, *pageHeight * i + top, width, height));

package/src/pipeline.cc

@@ -70,8 +70,8 @@ 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;
+      bool autoFlip = false;
+      bool autoFlop = false;
 
       if (baton->useExifOrientation) {
         // Rotate and flip image according to Exif orientation
@@ -88,7 +88,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           baton->rotationAngle != 0.0);
 
       if (shouldRotateBefore) {
-        image = sharp::StaySequential(image, access,
+        image = sharp::StaySequential(image,
           rotation != VIPS_ANGLE_D0 ||
           autoRotation != VIPS_ANGLE_D0 ||
           autoFlip ||
@@ -104,17 +104,17 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
         if (autoFlip) {
           image = image.flip(VIPS_DIRECTION_VERTICAL);
-          autoFlip = FALSE;
+          autoFlip = false;
         } else if (baton->flip) {
           image = image.flip(VIPS_DIRECTION_VERTICAL);
-          baton->flip = FALSE;
+          baton->flip = false;
         }
         if (autoFlop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-          autoFlop = FALSE;
+          autoFlop = false;
         } else if (baton->flop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-          baton->flop = FALSE;
+          baton->flop = false;
         }
         if (rotation != VIPS_ANGLE_D0) {
           if (rotation != VIPS_ANGLE_D180) {
@@ -126,7 +126,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (baton->rotationAngle != 0.0) {
           MultiPageUnsupported(nPages, "Rotate");
           std::vector<double> background;
-          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, FALSE);
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, false);
           image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background)).copy_memory();
         }
       }
@@ -134,7 +134,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Trim
       if (baton->trimThreshold >= 0.0) {
         MultiPageUnsupported(nPages, "Trim");
-        image = sharp::StaySequential(image, access);
+        image = sharp::StaySequential(image);
         image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold, baton->trimLineArt);
         baton->trimOffsetLeft = image.xoffset();
         baton->trimOffsetTop = image.yoffset();
@@ -337,7 +337,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Convert to sRGB/P3 using embedded profile
         try {
           image = image.icc_transform(processingProfile, VImage::option()
-            ->set("embedded", TRUE)
+            ->set("embedded", true)
             ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         } catch(...) {
@@ -357,11 +357,6 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::Flatten(image, baton->flattenBackground);
       }
 
-      // Negate the colours in the image
-      if (baton->negate) {
-        image = sharp::Negate(image, baton->negateAlpha);
-      }
-
       // Gamma encoding (darken)
       if (baton->gamma >= 1 && baton->gamma <= 3) {
         image = sharp::Gamma(image, 1.0 / baton->gamma);
@@ -397,7 +392,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           ->set("kernel", baton->kernel));
       }
 
-      image = sharp::StaySequential(image, access,
+      image = sharp::StaySequential(image,
         autoRotation != VIPS_ANGLE_D0 ||
         baton->flip ||
         autoFlip ||
@@ -500,7 +495,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
             // Attention-based or Entropy-based crop
             MultiPageUnsupported(nPages, "Resize strategy");
-            image = sharp::StaySequential(image, access);
+            image = sharp::StaySequential(image);
             image = image.smartcrop(baton->width, baton->height, VImage::option()
               ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION)
               ->set("premultiplied", shouldPremultiplyAlpha)
@@ -519,7 +514,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Rotate post-extract non-90 angle
       if (!baton->rotateBeforePreExtract && baton->rotationAngle != 0.0) {
         MultiPageUnsupported(nPages, "Rotate");
-        image = sharp::StaySequential(image, access);
+        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));
@@ -543,7 +538,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Affine transform
       if (!baton->affineMatrix.empty()) {
         MultiPageUnsupported(nPages, "Affine");
-        image = sharp::StaySequential(image, access);
+        image = sharp::StaySequential(image);
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
         vips::VInterpolate interp = vips::VInterpolate::new_from_name(
@@ -566,6 +561,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           std::vector<double> background;
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
 
+          image = sharp::StaySequential(image, nPages > 1);
           image = nPages > 1
             ? sharp::EmbedMultiPage(image,
                 baton->extendLeft, baton->extendTop, baton->width, baton->height,
@@ -574,7 +570,7 @@ class PipelineWorker : public Napi::AsyncWorker {
                 VImage::option()->set("extend", baton->extendWith)->set("background", background));
         } else {
           std::vector<double> ignoredBackground(1);
-          image = sharp::StaySequential(image, baton->input->access);
+          image = sharp::StaySequential(image);
           image = nPages > 1
             ? sharp::EmbedMultiPage(image,
                 baton->extendLeft, baton->extendTop, baton->width, baton->height,
@@ -670,7 +666,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             if (across != 0 || down != 0) {
               int left;
               int top;
-              compositeImage = sharp::StaySequential(compositeImage, access).replicate(across, down);
+              compositeImage = sharp::StaySequential(compositeImage).replicate(across, down);
               if (composite->hasOffset) {
                 std::tie(left, top) = sharp::CalculateCrop(
                   compositeImage.width(), compositeImage.height(), image.width(), image.height(),
@@ -728,13 +724,13 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Apply normalisation - stretch luminance to cover full dynamic range
       if (baton->normalise) {
-        image = sharp::StaySequential(image, access);
+        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) {
-        image = sharp::StaySequential(image, access);
+        image = sharp::StaySequential(image);
         image = sharp::Clahe(image, baton->claheWidth, baton->claheHeight, baton->claheMaxSlope);
       }
 
@@ -780,7 +776,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         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("embedded", true)
             ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         }
@@ -811,7 +807,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         try {
           image = image.icc_transform(const_cast<char*>(baton->withIccProfile.data()), VImage::option()
             ->set("input_profile", processingProfile)
-            ->set("embedded", TRUE)
+            ->set("embedded", true)
             ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         } catch(...) {
@@ -820,6 +816,12 @@ class PipelineWorker : public Napi::AsyncWorker {
       } 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);
+      }
+
       // Override EXIF Orientation tag
       if (baton->withMetadataOrientation != -1) {
         image = sharp::SetExifOrientation(image, baton->withMetadataOrientation);
@@ -1004,7 +1006,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (!sharp::HasAlpha(image)) {
             baton->tileBackground.pop_back();
           }
-          image = sharp::StaySequential(image, access, baton->tileAngle != 0);
+          image = sharp::StaySequential(image, baton->tileAngle != 0);
           vips::VOption *options = BuildOptionsDZ(baton);
           VipsArea *area = reinterpret_cast<VipsArea*>(image.dzsave_buffer(options));
           baton->bufferOut = static_cast<char*>(area->data);
@@ -1206,7 +1208,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (!sharp::HasAlpha(image)) {
             baton->tileBackground.pop_back();
           }
-          image = sharp::StaySequential(image, access, baton->tileAngle != 0);
+          image = sharp::StaySequential(image, baton->tileAngle != 0);
           vips::VOption *options = BuildOptionsDZ(baton);
           image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
@@ -1338,16 +1340,16 @@ class PipelineWorker : public Napi::AsyncWorker {
   std::tuple<VipsAngle, bool, bool>
   CalculateExifRotationAndFlip(int const exifOrientation) {
     VipsAngle rotate = VIPS_ANGLE_D0;
-    bool flip = FALSE;
-    bool flop = FALSE;
+    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;  // 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
     }
     return std::make_tuple(rotate, flip, flop);
   }
@@ -1395,7 +1397,7 @@ class PipelineWorker : public Napi::AsyncWorker {
     std::string suffix;
     if (baton->tileFormat == "png") {
       std::vector<std::pair<std::string, std::string>> options {
-        {"interlace", baton->pngProgressive ? "TRUE" : "FALSE"},
+        {"interlace", baton->pngProgressive ? "true" : "false"},
         {"compression", std::to_string(baton->pngCompressionLevel)},
         {"filter", baton->pngAdaptiveFiltering ? "all" : "none"}
       };
@@ -1404,25 +1406,25 @@ class PipelineWorker : public Napi::AsyncWorker {
       std::vector<std::pair<std::string, std::string>> options {
         {"Q", std::to_string(baton->webpQuality)},
         {"alpha_q", std::to_string(baton->webpAlphaQuality)},
-        {"lossless", baton->webpLossless ? "TRUE" : "FALSE"},
-        {"near_lossless", baton->webpNearLossless ? "TRUE" : "FALSE"},
-        {"smart_subsample", baton->webpSmartSubsample ? "TRUE" : "FALSE"},
+        {"lossless", baton->webpLossless ? "true" : "false"},
+        {"near_lossless", baton->webpNearLossless ? "true" : "false"},
+        {"smart_subsample", baton->webpSmartSubsample ? "true" : "false"},
         {"preset", vips_enum_nick(VIPS_TYPE_FOREIGN_WEBP_PRESET, baton->webpPreset)},
-        {"min_size", baton->webpMinSize ? "TRUE" : "FALSE"},
-        {"mixed", baton->webpMixed ? "TRUE" : "FALSE"},
+        {"min_size", baton->webpMinSize ? "true" : "false"},
+        {"mixed", baton->webpMixed ? "true" : "false"},
         {"effort", std::to_string(baton->webpEffort)}
       };
       suffix = AssembleSuffixString(".webp", options);
     } else {
       std::vector<std::pair<std::string, std::string>> options {
         {"Q", std::to_string(baton->jpegQuality)},
-        {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
+        {"interlace", baton->jpegProgressive ? "true" : "false"},
         {"subsample_mode", baton->jpegChromaSubsampling == "4:4:4" ? "off" : "on"},
-        {"trellis_quant", baton->jpegTrellisQuantisation ? "TRUE" : "FALSE"},
+        {"trellis_quant", baton->jpegTrellisQuantisation ? "true" : "false"},
         {"quant_table", std::to_string(baton->jpegQuantisationTable)},
-        {"overshoot_deringing", baton->jpegOvershootDeringing ? "TRUE": "FALSE"},
-        {"optimize_scans", baton->jpegOptimiseScans ? "TRUE": "FALSE"},
-        {"optimize_coding", baton->jpegOptimiseCoding ? "TRUE": "FALSE"}
+        {"overshoot_deringing", baton->jpegOvershootDeringing ? "true": "false"},
+        {"optimize_scans", baton->jpegOptimiseScans ? "true": "false"},
+        {"optimize_coding", baton->jpegOptimiseCoding ? "true": "false"}
       };
       std::string extname = baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_DZ ? ".jpeg" : ".jpg";
       suffix = AssembleSuffixString(extname, options);