sharp 0.33.5 → 0.34.0-rc.1

package/src/pipeline.cc

@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <filesystem>
 #include <map>
 #include <memory>
 #include <numeric>
@@ -20,17 +21,6 @@
 #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
-
 class PipelineWorker : public Napi::AsyncWorker {
  public:
   PipelineWorker(Napi::Function callback, PipelineBaton *baton,
@@ -52,7 +42,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);
 
@@ -73,14 +95,14 @@ class PipelineWorker : public Napi::AsyncWorker {
       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);
       }
 
+      rotation = CalculateAngleRotation(baton->angle);
+
       // Rotate pre-extract
       bool const shouldRotateBefore = baton->rotateBeforePreExtract &&
         (rotation != VIPS_ANGLE_D0 || autoRotation != VIPS_ANGLE_D0 ||
@@ -102,18 +124,14 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = image.rot(autoRotation);
           autoRotation = VIPS_ANGLE_D0;
         }
-        if (autoFlip) {
+        if (autoFlip != baton->flip) {
           image = image.flip(VIPS_DIRECTION_VERTICAL);
           autoFlip = false;
-        } else if (baton->flip) {
-          image = image.flip(VIPS_DIRECTION_VERTICAL);
           baton->flip = false;
         }
-        if (autoFlop) {
+        if (autoFlop != baton->flop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
           autoFlop = false;
-        } else if (baton->flop) {
-          image = image.flip(VIPS_DIRECTION_HORIZONTAL);
           baton->flop = false;
         }
         if (rotation != VIPS_ANGLE_D0) {
@@ -354,7 +372,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 +392,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) {
@@ -406,11 +424,11 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.rot(autoRotation);
       }
       // Mirror vertically (up-down) about the x-axis
-      if (baton->flip || autoFlip) {
+      if (baton->flip != autoFlip) {
         image = image.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);
       }
       // Rotate post-extract 90-angle
@@ -591,6 +609,16 @@ 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);
@@ -641,6 +669,30 @@ class PipelineWorker : public Napi::AsyncWorker {
           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 compositeAutoFlip = false;
+            bool compositeAutoFlop = false;
+            std::tie(compositeAutoRotation, compositeAutoFlip, compositeAutoFlop) =
+              CalculateExifRotationAndFlip(sharp::ExifOrientation(compositeImage));
+
+            compositeImage = sharp::RemoveExifOrientation(compositeImage);
+            compositeImage = sharp::StaySequential(compositeImage,
+              compositeAutoRotation != VIPS_ANGLE_D0 || compositeAutoFlip);
+
+            if (compositeAutoRotation != VIPS_ANGLE_D0) {
+              compositeImage = compositeImage.rot(compositeAutoRotation);
+            }
+            if (compositeAutoFlip) {
+              compositeImage = compositeImage.flip(VIPS_DIRECTION_VERTICAL);
+            }
+            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");
@@ -683,9 +735,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           // Ensure image to composite is sRGB with unpremultiplied alpha
           compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
-          if (!sharp::HasAlpha(compositeImage)) {
-            compositeImage = sharp::EnsureAlpha(compositeImage, 1);
-          }
+          compositeImage = sharp::EnsureAlpha(compositeImage, 1);
           if (composite->premultiplied) compositeImage = compositeImage.unpremultiply();
           // Calculate position
           int left;
@@ -786,7 +836,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Extract channel
       if (baton->extractChannel > -1) {
         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)
@@ -929,6 +979,7 @@ 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)
@@ -991,7 +1042,7 @@ 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)
@@ -1009,7 +1060,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);
@@ -1058,6 +1109,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Unsupported output format
           (baton->err).append("Unsupported output format ");
           if (baton->formatOut == "input") {
+            (baton->err).append("when trying to match input format of ");
             (baton->err).append(ImageTypeId(inputImageType));
           } else {
             (baton->err).append(baton->formatOut);
@@ -1136,6 +1188,7 @@ 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)
@@ -1184,7 +1237,7 @@ 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)
@@ -1211,7 +1264,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);
@@ -1304,9 +1357,11 @@ class PipelineWorker : public Napi::AsyncWorker {
         Callback().Call(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(baton->fileOut));
+            info.Set("size", size);
+          } catch (...) {}
         }
         Callback().Call(Receiver().Value(), { env.Null(), info });
       }
@@ -1324,6 +1379,9 @@ 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
@@ -1419,6 +1477,7 @@ 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"},
@@ -1480,6 +1539,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");
@@ -1564,6 +1631,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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,7 +1641,6 @@ 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");
@@ -1649,6 +1717,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   }
   baton->withExifMerge = sharp::AttrAsBool(options, "withExifMerge");
   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,6 +1746,7 @@ 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");
@@ -1717,13 +1788,6 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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");

package/src/pipeline.h

@@ -39,6 +39,7 @@ struct Composite {
 
 struct PipelineBaton {
   sharp::InputDescriptor *input;
+  std::vector<sharp::InputDescriptor *> join;
   std::string formatOut;
   std::string fileOut;
   void *bufferOut;
@@ -100,6 +101,8 @@ struct PipelineBaton {
   int trimOffsetTop;
   std::vector<double> linearA;
   std::vector<double> linearB;
+  int dilateWidth;
+  int erodeWidth;
   double gamma;
   double gammaOut;
   bool greyscale;
@@ -109,7 +112,6 @@ struct PipelineBaton {
   int claheWidth;
   int claheHeight;
   int claheMaxSlope;
-  bool useExifOrientation;
   int angle;
   double rotationAngle;
   std::vector<double> rotationBackground;
@@ -157,6 +159,7 @@ struct PipelineBaton {
   bool webpNearLossless;
   bool webpLossless;
   bool webpSmartSubsample;
+  bool webpSmartDeblock;
   VipsForeignWebpPreset webpPreset;
   int webpEffort;
   bool webpMinSize;
@@ -273,6 +276,8 @@ struct PipelineBaton {
     trimOffsetTop(0),
     linearA{},
     linearB{},
+    dilateWidth(0),
+    erodeWidth(0),
     gamma(0.0),
     greyscale(false),
     normalise(false),
@@ -281,7 +286,6 @@ struct PipelineBaton {
     claheWidth(0),
     claheHeight(0),
     claheMaxSlope(3),
-    useExifOrientation(false),
     angle(0),
     rotationAngle(0.0),
     rotationBackground{ 0.0, 0.0, 0.0, 255.0 },
@@ -328,6 +332,7 @@ struct PipelineBaton {
     webpNearLossless(false),
     webpLossless(false),
     webpSmartSubsample(false),
+    webpSmartDeblock(false),
     webpPreset(VIPS_FOREIGN_WEBP_PRESET_DEFAULT),
     webpEffort(4),
     webpMinSize(false),
@@ -379,7 +384,7 @@ struct PipelineBaton {
     ensureAlpha(-1.0),
     colourspacePipeline(VIPS_INTERPRETATION_LAST),
     colourspace(VIPS_INTERPRETATION_LAST),
-    loop(-1),
+    loop(1),
     tileSize(256),
     tileOverlap(0),
     tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),

package/src/sharp.cc

@@ -33,6 +33,7 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("block", Napi::Function::New(env, block));
   exports.Set("_maxColourDistance", Napi::Function::New(env, _maxColourDistance));
   exports.Set("_isUsingJemalloc", Napi::Function::New(env, _isUsingJemalloc));
+  exports.Set("_isUsingX64V2", Napi::Function::New(env, _isUsingX64V2));
   exports.Set("stats", Napi::Function::New(env, stats));
   return exports;
 }

package/src/stats.cc

@@ -58,7 +58,7 @@ class StatsWorker : public Napi::AsyncWorker {
           baton->channelStats.push_back(cStats);
         }
         // Image is not opaque when alpha layer is present and contains a non-mamixa value
-        if (sharp::HasAlpha(image)) {
+        if (image.has_alpha()) {
           double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
           if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
             baton->isOpaque = false;

package/src/utilities.cc

@@ -119,7 +119,7 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   Napi::Object format = Napi::Object::New(env);
   for (std::string const f : {
     "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
-    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl", "rad"
   }) {
     // Input
     const VipsObjectClass *oc = vips_class_find("VipsOperation", (f + "load").c_str());
@@ -233,10 +233,10 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
   double maxColourDistance;
   try {
     // Premultiply and remove alpha
-    if (sharp::HasAlpha(image1)) {
+    if (image1.has_alpha()) {
       image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
     }
-    if (sharp::HasAlpha(image2)) {
+    if (image2.has_alpha()) {
       image2 = image2.premultiply().extract_band(1, VImage::option()->set("n", image2.bands() - 1));
     }
     // Calculate colour distance
@@ -267,3 +267,20 @@ Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, false);
 }
 #endif
+
+#if defined(__GNUC__) && defined(__x86_64__)
+// Are SSE 4.2 intrinsics available at runtime?
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  unsigned int eax, ebx, ecx, edx;
+  __asm__ __volatile__("cpuid"
+    : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
+    : "a"(1));
+  return Napi::Boolean::New(env, (ecx & 1U << 20) != 0);
+}
+#else
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

package/src/utilities.h

@@ -15,5 +15,6 @@ Napi::Value format(const Napi::CallbackInfo& info);
 void block(const Napi::CallbackInfo& info);
 Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
 Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info);
 
 #endif  // SRC_UTILITIES_H_