@basemaps/lambda-tiler 6.19.0 → 6.20.0

package/dist/node_modules/sharp/src/pipeline.cc

@@ -67,6 +67,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       vips::VImage image;
       sharp::ImageType inputImageType;
       std::tie(image, inputImageType) = sharp::OpenInput(baton->input);
+      image = sharp::EnsureColourspace(image, baton->colourspaceInput);
 
       // Calculate angle of rotation
       VipsAngle rotation;
@@ -89,7 +90,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
         if (baton->rotationAngle != 0.0) {
           std::vector<double> background;
-          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, FALSE);
           image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
         }
       }
@@ -214,7 +215,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       double yresidual = static_cast<double>(yshrink) / yfactor;
 
       // If integral x and y shrink are equal, try to use shrink-on-load for JPEG and WebP,
-      // but not when applying gamma correction, pre-resize extract or trim
+      // but not when applying gamma correction, pre-resize extract, trim or input colourspace
       int shrink_on_load = 1;
 
       int shrink_on_load_factor = 1;
@@ -227,6 +228,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
         (inputImageType == sharp::ImageType::JPEG || inputImageType == sharp::ImageType::WEBP) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0 &&
+        baton->colourspaceInput == VIPS_INTERPRETATION_LAST &&
         image.width() > 3 && image.height() > 3 && baton->input->pages == 1
       ) {
         if (xshrink >= 8 * shrink_on_load_factor) {
@@ -287,16 +289,21 @@ class PipelineWorker : public Napi::AsyncWorker {
           yfactor = static_cast<double>(shrunkOnLoadHeight) / static_cast<double>(targetResizeHeight);
         }
       }
+      // Remove animation properties from single page images
+      if (baton->input->pages == 1) {
+        image = sharp::RemoveAnimationProperties(image);
+      }
 
       // Ensure we're using a device-independent colour space
+      char const *processingProfile = image.interpretation() == VIPS_INTERPRETATION_RGB16 ? "p3" : "srgb";
       if (
         sharp::HasProfile(image) &&
         image.interpretation() != VIPS_INTERPRETATION_LABS &&
         image.interpretation() != VIPS_INTERPRETATION_GREY16
       ) {
-        // Convert to sRGB using embedded profile
+        // Convert to sRGB/P3 using embedded profile
         try {
-          image = image.icc_transform("srgb", VImage::option()
+          image = image.icc_transform(processingProfile, VImage::option()
             ->set("embedded", TRUE)
             ->set("depth", image.interpretation() == VIPS_INTERPRETATION_RGB16 ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
@@ -304,7 +311,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Ignore failure of embedded profile
         }
       } else if (image.interpretation() == VIPS_INTERPRETATION_CMYK) {
-        image = image.icc_transform("srgb", VImage::option()
+        image = image.icc_transform(processingProfile, VImage::option()
           ->set("input_profile", "cmyk")
           ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
@@ -325,7 +332,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Negate the colours in the image
       if (baton->negate) {
-        image = image.invert();
+        image = sharp::Negate(image, baton->negateAlpha);
       }
 
       // Gamma encoding (darken)
@@ -344,7 +351,8 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldSharpen = baton->sharpenSigma != 0.0;
       bool const shouldApplyMedian = baton->medianSize > 0;
       bool const shouldComposite = !baton->composite.empty();
-      bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0;
+      bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 ||
+                                  baton->hue != 0.0 || baton->lightness != 0.0;
       bool const shouldApplyClahe = baton->claheWidth != 0 && baton->claheHeight != 0;
 
       if (shouldComposite && !sharp::HasAlpha(image)) {
@@ -374,11 +382,15 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Ensure shortest edge is at least 1 pixel
         if (image.width() / xfactor < 0.5) {
           xfactor = 2 * image.width();
-          baton->width = 1;
+          if (baton->canvas != Canvas::EMBED) {
+            baton->width = 1;
+          }
         }
         if (image.height() / yfactor < 0.5) {
           yfactor = 2 * image.height();
-          baton->height = 1;
+          if (baton->canvas != Canvas::EMBED) {
+            baton->height = 1;
+          }
         }
         image = image.resize(1.0 / xfactor, VImage::option()
           ->set("vscale", 1.0 / yfactor)
@@ -411,6 +423,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
         for (unsigned int i = 0; i < baton->joinChannelIn.size(); i++) {
           std::tie(joinImage, joinImageType) = sharp::OpenInput(baton->joinChannelIn[i]);
+          joinImage = sharp::EnsureColourspace(joinImage, baton->colourspaceInput);
           image = image.bandjoin(joinImage);
         }
         image = image.copy(VImage::option()->set("interpretation", baton->colourspace));
@@ -420,7 +433,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (image.width() != baton->width || image.height() != baton->height) {
         if (baton->canvas == Canvas::EMBED) {
           std::vector<double> background;
-          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground);
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground, shouldPremultiplyAlpha);
 
           // Embed
 
@@ -477,7 +490,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Rotate post-extract non-90 angle
       if (!baton->rotateBeforePreExtract && baton->rotationAngle != 0.0) {
         std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, shouldPremultiplyAlpha);
         image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
       }
 
@@ -490,7 +503,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Affine transform
       if (baton->affineMatrix.size() > 0) {
         std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
         image = image.affine(baton->affineMatrix, VImage::option()->set("background", background)
           ->set("idx", baton->affineIdx)
           ->set("idy", baton->affineIdy)
@@ -502,7 +515,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Extend edges
       if (baton->extendTop > 0 || baton->extendBottom > 0 || baton->extendLeft > 0 || baton->extendRight > 0) {
         std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
 
         // Embed
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
@@ -539,7 +552,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       if (shouldModulate) {
-        image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue);
+        image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue, baton->lightness);
       }
 
       // Sharpen
@@ -552,7 +565,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         for (Composite *composite : baton->composite) {
           VImage compositeImage;
           sharp::ImageType compositeImageType = sharp::ImageType::UNKNOWN;
-          std::tie(compositeImage, compositeImageType) = OpenInput(composite->input);
+          std::tie(compositeImage, compositeImageType) = sharp::OpenInput(composite->input);
+          compositeImage = sharp::EnsureColourspace(compositeImage, baton->colourspaceInput);
           // 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");
@@ -661,6 +675,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         VImage booleanImage;
         sharp::ImageType booleanImageType = sharp::ImageType::UNKNOWN;
         std::tie(booleanImage, booleanImageType) = sharp::OpenInput(baton->boolean);
+        booleanImage = sharp::EnsureColourspace(booleanImage, baton->colourspaceInput);
         image = sharp::Boolean(image, booleanImage, baton->booleanOp);
       }
 
@@ -710,9 +725,10 @@ class PipelineWorker : public Napi::AsyncWorker {
         // 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->withMetadata && sharp::HasProfile(image)) {
-          image = image.icc_transform(vips_enum_nick(VIPS_TYPE_INTERPRETATION, baton->colourspace),
-            VImage::option()->set("embedded", TRUE));
+        if (baton->withMetadata && sharp::HasProfile(image) && baton->withMetadataIcc.empty()) {
+          image = image.icc_transform("srgb", VImage::option()
+            ->set("embedded", TRUE)
+            ->set("intent", VIPS_INTENT_PERCEPTUAL));
         }
       }
 
@@ -721,7 +737,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.icc_transform(
           const_cast<char*>(baton->withMetadataIcc.data()),
           VImage::option()
-            ->set("input_profile", "srgb")
+            ->set("input_profile", processingProfile)
+            ->set("embedded", TRUE)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
       // Override EXIF Orientation tag
@@ -755,6 +772,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         baton->loop);
 
       // Output
+      sharp::SetTimeout(image, baton->timeoutSeconds);
       if (baton->fileOut.empty()) {
         // Buffer output
         if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
@@ -765,8 +783,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->jpegQuality)
             ->set("interlace", baton->jpegProgressive)
             ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_JPEG_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_JPEG_SUBSAMPLE_ON)
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF
+              : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
             ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
@@ -782,6 +800,22 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else {
             baton->channels = std::min(baton->channels, 3);
           }
+        } else if (baton->formatOut == "jp2" || (baton->formatOut == "input"
+          && inputImageType == sharp::ImageType::JP2)) {
+          // Write JP2 to Buffer
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jp2ksave_buffer(VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth)));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (baton->formatOut == "input" &&
           (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
            inputImageType == sharp::ImageType::SVG))) {
@@ -794,7 +828,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
             ->set("palette", baton->pngPalette)
             ->set("Q", baton->pngQuality)
-            ->set("colours", baton->pngColours)
+            ->set("bitdepth", baton->pngBitdepth)
             ->set("dither", baton->pngDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -863,15 +897,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         } else if (baton->formatOut == "heif" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to buffer
+          image = sharp::RemoveAnimationProperties(image);
           VipsArea *area = reinterpret_cast<VipsArea*>(image.heifsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
-            ->set("compression", baton->heifCompression)
             ->set("Q", baton->heifQuality)
+            ->set("compression", baton->heifCompression)
             ->set("speed", baton->heifSpeed)
-#if defined(VIPS_TYPE_FOREIGN_SUBSAMPLE)
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
-#endif
             ->set("lossless", baton->heifLossless)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -886,9 +919,9 @@ class PipelineWorker : public Napi::AsyncWorker {
             image = image[0];
             baton->channels = 1;
           }
-          if (image.format() != VIPS_FORMAT_UCHAR) {
-            // Cast pixels to uint8 (unsigned char)
-            image = image.cast(VIPS_FORMAT_UCHAR);
+          if (image.format() != baton->rawDepth) {
+            // Cast pixels to requested format
+            image = image.cast(baton->rawDepth);
           }
           // Get raw image data
           baton->bufferOut = static_cast<char*>(image.write_to_memory(&baton->bufferOutLength));
@@ -914,13 +947,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         bool const isWebp = sharp::IsWebp(baton->fileOut);
         bool const isGif = sharp::IsGif(baton->fileOut);
         bool const isTiff = sharp::IsTiff(baton->fileOut);
+        bool const isJp2 = sharp::IsJp2(baton->fileOut);
         bool const isHeif = sharp::IsHeif(baton->fileOut);
         bool const isDz = sharp::IsDz(baton->fileOut);
         bool const isDzZip = sharp::IsDzZip(baton->fileOut);
         bool const isV = sharp::IsV(baton->fileOut);
         bool const mightMatchInput = baton->formatOut == "input";
         bool const willMatchInput = mightMatchInput &&
-         !(isJpeg || isPng || isWebp || isGif || isTiff || isHeif || isDz || isDzZip || isV);
+         !(isJpeg || isPng || isWebp || isGif || isTiff || isJp2 || isHeif || isDz || isDzZip || isV);
 
         if (baton->formatOut == "jpeg" || (mightMatchInput && isJpeg) ||
           (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
@@ -931,8 +965,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->jpegQuality)
             ->set("interlace", baton->jpegProgressive)
             ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_JPEG_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_JPEG_SUBSAMPLE_ON)
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF
+              : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
             ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
@@ -940,6 +974,18 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("optimize_coding", baton->jpegOptimiseCoding));
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
+        } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
+          (willMatchInput && (inputImageType == sharp::ImageType::JP2))) {
+          // Write JP2 to file
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          image.jp2ksave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth));
+            baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (mightMatchInput && isPng) || (willMatchInput &&
           (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
            inputImageType == sharp::ImageType::SVG))) {
@@ -952,7 +998,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
             ->set("palette", baton->pngPalette)
             ->set("Q", baton->pngQuality)
-            ->set("colours", baton->pngColours)
+            ->set("bitdepth", baton->pngBitdepth)
             ->set("dither", baton->pngDither));
           baton->formatOut = "png";
         } else if (baton->formatOut == "webp" || (mightMatchInput && isWebp) ||
@@ -1005,15 +1051,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         } else if (baton->formatOut == "heif" || (mightMatchInput && isHeif) ||
           (willMatchInput && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to file
+          image = sharp::RemoveAnimationProperties(image);
           image.heifsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
             ->set("speed", baton->heifSpeed)
-#if defined(VIPS_TYPE_FOREIGN_SUBSAMPLE)
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
-#endif
             ->set("lossless", baton->heifLossless));
           baton->formatOut = "heif";
         } else if (baton->formatOut == "dz" || isDz || isDzZip) {
@@ -1130,6 +1175,9 @@ class PipelineWorker : public Napi::AsyncWorker {
       info.Set("width", static_cast<uint32_t>(width));
       info.Set("height", static_cast<uint32_t>(height));
       info.Set("channels", static_cast<uint32_t>(baton->channels));
+      if (baton->formatOut == "raw") {
+        info.Set("depth", vips_enum_nick(VIPS_TYPE_BAND_FORMAT, baton->rawDepth));
+      }
       info.Set("premultiplied", baton->premultiplied);
       if (baton->hasCropOffset) {
         info.Set("cropOffsetLeft", static_cast<int32_t>(baton->cropOffsetLeft));
@@ -1319,10 +1367,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->flatten = sharp::AttrAsBool(options, "flatten");
   baton->flattenBackground = sharp::AttrAsVectorOfDouble(options, "flattenBackground");
   baton->negate = sharp::AttrAsBool(options, "negate");
+  baton->negateAlpha = sharp::AttrAsBool(options, "negateAlpha");
   baton->blurSigma = sharp::AttrAsDouble(options, "blurSigma");
   baton->brightness = sharp::AttrAsDouble(options, "brightness");
   baton->saturation = sharp::AttrAsDouble(options, "saturation");
   baton->hue = sharp::AttrAsInt32(options, "hue");
+  baton->lightness = sharp::AttrAsDouble(options, "lightness");
   baton->medianSize = sharp::AttrAsUint32(options, "medianSize");
   baton->sharpenSigma = sharp::AttrAsDouble(options, "sharpenSigma");
   baton->sharpenFlat = sharp::AttrAsDouble(options, "sharpenFlat");
@@ -1389,6 +1439,10 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
        baton->recombMatrix[i] = sharp::AttrAsDouble(recombMatrix, i);
     }
   }
+  baton->colourspaceInput = sharp::GetInterpretation(sharp::AttrAsStr(options, "colourspaceInput"));
+  if (baton->colourspaceInput == VIPS_INTERPRETATION_ERROR) {
+    baton->colourspaceInput = VIPS_INTERPRETATION_LAST;
+  }
   baton->colourspace = sharp::GetInterpretation(sharp::AttrAsStr(options, "colourspace"));
   if (baton->colourspace == VIPS_INTERPRETATION_ERROR) {
     baton->colourspace = VIPS_INTERPRETATION_sRGB;
@@ -1406,6 +1460,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     std::string k = sharp::AttrAsStr(mdStrKeys, i);
     baton->withMetadataStrs.insert(std::make_pair(k, sharp::AttrAsStr(mdStrs, k)));
   }
+  baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
   // Format-specific
   baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
   baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");
@@ -1420,8 +1475,13 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->pngAdaptiveFiltering = sharp::AttrAsBool(options, "pngAdaptiveFiltering");
   baton->pngPalette = sharp::AttrAsBool(options, "pngPalette");
   baton->pngQuality = sharp::AttrAsUint32(options, "pngQuality");
-  baton->pngColours = sharp::AttrAsUint32(options, "pngColours");
+  baton->pngBitdepth = sharp::AttrAsUint32(options, "pngBitdepth");
   baton->pngDither = sharp::AttrAsDouble(options, "pngDither");
+  baton->jp2Quality = sharp::AttrAsUint32(options, "jp2Quality");
+  baton->jp2Lossless = sharp::AttrAsBool(options, "jp2Lossless");
+  baton->jp2TileHeight = sharp::AttrAsUint32(options, "jp2TileHeight");
+  baton->jp2TileWidth = sharp::AttrAsUint32(options, "jp2TileWidth");
+  baton->jp2ChromaSubsampling = sharp::AttrAsStr(options, "jp2ChromaSubsampling");
   baton->webpQuality = sharp::AttrAsUint32(options, "webpQuality");
   baton->webpAlphaQuality = sharp::AttrAsUint32(options, "webpAlphaQuality");
   baton->webpLossless = sharp::AttrAsBool(options, "webpLossless");
@@ -1436,6 +1496,9 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->tiffTileHeight = sharp::AttrAsUint32(options, "tiffTileHeight");
   baton->tiffXres = sharp::AttrAsDouble(options, "tiffXres");
   baton->tiffYres = sharp::AttrAsDouble(options, "tiffYres");
+  if (baton->tiffXres == 1.0 && baton->tiffYres == 1.0 && baton->withMetadataDensity > 0) {
+    baton->tiffXres = baton->tiffYres = baton->withMetadataDensity / 25.4;
+  }
   // tiff compression options
   baton->tiffCompression = static_cast<VipsForeignTiffCompression>(
   vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_COMPRESSION,
@@ -1451,6 +1514,11 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->heifSpeed = sharp::AttrAsUint32(options, "heifSpeed");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
 
+  // Raw output
+  baton->rawDepth = static_cast<VipsBandFormat>(
+    vips_enum_from_nick(nullptr, VIPS_TYPE_BAND_FORMAT,
+    sharp::AttrAsStr(options, "rawDepth").data()));
+
   // Animated output
   if (sharp::HasAttr(options, "pageHeight")) {
     baton->pageHeight = sharp::AttrAsUint32(options, "pageHeight");

package/dist/node_modules/sharp/src/pipeline.h

@@ -90,10 +90,12 @@ struct PipelineBaton {
   bool flatten;
   std::vector<double> flattenBackground;
   bool negate;
+  bool negateAlpha;
   double blurSigma;
   double brightness;
   double saturation;
   int hue;
+  double lightness;
   int medianSize;
   double sharpenSigma;
   double sharpenFlat;
@@ -145,8 +147,13 @@ struct PipelineBaton {
   bool pngAdaptiveFiltering;
   bool pngPalette;
   int pngQuality;
-  int pngColours;
+  int pngBitdepth;
   double pngDither;
+  int jp2Quality;
+  bool jp2Lossless;
+  int jp2TileHeight;
+  int jp2TileWidth;
+  std::string jp2ChromaSubsampling;
   int webpQuality;
   int webpAlphaQuality;
   bool webpNearLossless;
@@ -168,12 +175,14 @@ struct PipelineBaton {
   int heifSpeed;
   std::string heifChromaSubsampling;
   bool heifLossless;
+  VipsBandFormat rawDepth;
   std::string err;
   bool withMetadata;
   int withMetadataOrientation;
   double withMetadataDensity;
   std::string withMetadataIcc;
   std::unordered_map<std::string, std::string> withMetadataStrs;
+  int timeoutSeconds;
   std::unique_ptr<double[]> convKernel;
   int convKernelWidth;
   int convKernelHeight;
@@ -185,6 +194,7 @@ struct PipelineBaton {
   int extractChannel;
   bool removeAlpha;
   double ensureAlpha;
+  VipsInterpretation colourspaceInput;
   VipsInterpretation colourspace;
   int pageHeight;
   std::vector<int> delay;
@@ -219,10 +229,12 @@ struct PipelineBaton {
     flatten(false),
     flattenBackground{ 0.0, 0.0, 0.0 },
     negate(false),
+    negateAlpha(true),
     blurSigma(0.0),
     brightness(1.0),
     saturation(1.0),
     hue(0),
+    lightness(0),
     medianSize(0),
     sharpenSigma(0.0),
     sharpenFlat(1.0),
@@ -272,8 +284,13 @@ struct PipelineBaton {
     pngAdaptiveFiltering(false),
     pngPalette(false),
     pngQuality(100),
-    pngColours(256),
+    pngBitdepth(8),
     pngDither(1.0),
+    jp2Quality(80),
+    jp2Lossless(false),
+    jp2TileHeight(512),
+    jp2TileWidth(512),
+    jp2ChromaSubsampling("4:4:4"),
     webpQuality(80),
     webpAlphaQuality(100),
     webpNearLossless(false),
@@ -293,11 +310,13 @@ struct PipelineBaton {
     heifQuality(50),
     heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
     heifSpeed(5),
-    heifChromaSubsampling("4:2:0"),
+    heifChromaSubsampling("4:4:4"),
     heifLossless(false),
+    rawDepth(VIPS_FORMAT_UCHAR),
     withMetadata(false),
     withMetadataOrientation(-1),
     withMetadataDensity(0.0),
+    timeoutSeconds(0),
     convKernelWidth(0),
     convKernelHeight(0),
     convKernelScale(0.0),
@@ -308,6 +327,7 @@ struct PipelineBaton {
     extractChannel(-1),
     removeAlpha(false),
     ensureAlpha(-1.0),
+    colourspaceInput(VIPS_INTERPRETATION_LAST),
     colourspace(VIPS_INTERPRETATION_LAST),
     pageHeight(0),
     delay{-1},

package/dist/node_modules/sharp/src/utilities.cc

@@ -115,7 +115,7 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   Napi::Object format = Napi::Object::New(env);
   for (std::string const f : {
     "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
-    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k"
   }) {
     // Input
     Napi::Boolean hasInputFile =

package/dist/node_modules/sharp/vendor/{8.10.6 → 8.11.3/linux-x64}/THIRD-PARTY-NOTICES.md

@@ -8,12 +8,10 @@ used under the terms of the following licences:
 | aom           | BSD 2-Clause + [Alliance for Open Media Patent License 1.0](https://aomedia.org/license/patent-license/)  |
 | cairo         | Mozilla Public License 2.0                                                                                |
 | expat         | MIT Licence                                                                                               |
-| fontconfig    | [fontconfig Licence](https://gitlab.freedesktop.org/fontconfig/fontconfig/blob/master/COPYING) (BSD-like) |
+| fontconfig    | [fontconfig Licence](https://gitlab.freedesktop.org/fontconfig/fontconfig/blob/main/COPYING) (BSD-like) |
 | freetype      | [freetype Licence](https://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
 | fribidi       | LGPLv3                                                                                                    |
 | gdk-pixbuf    | LGPLv3                                                                                                    |
-| gettext       | LGPLv3                                                                                                    |
-| giflib        | MIT Licence                                                                                               |
 | glib          | LGPLv3                                                                                                    |
 | harfbuzz      | MIT Licence                                                                                               |
 | lcms          | MIT Licence                                                                                               |
@@ -33,6 +31,7 @@ used under the terms of the following licences:
 | orc           | [orc License](https://gitlab.freedesktop.org/gstreamer/orc/blob/master/COPYING) (BSD-like)                |
 | pango         | LGPLv3                                                                                                    |
 | pixman        | MIT Licence                                                                                               |
+| proxy-libintl | LGPLv3                                                                                                    |
 | zlib-ng       | [zlib Licence](https://github.com/zlib-ng/zlib-ng/blob/develop/LICENSE.md)                                |
 
 Use of libraries under the terms of the LGPLv3 is via the

package/dist/node_modules/sharp/vendor/8.11.3/linux-x64/versions.json

@@ -0,0 +1,30 @@
+{
+  "aom": "3.1.2",
+  "cairo": "1.17.4",
+  "exif": "0.6.22",
+  "expat": "2.4.1",
+  "ffi": "3.4.2",
+  "fontconfig": "2.13.93",
+  "freetype": "2.10.4",
+  "fribidi": "1.0.10",
+  "gdkpixbuf": "2.42.6",
+  "glib": "2.69.1",
+  "gsf": "1.14.47",
+  "harfbuzz": "2.8.2",
+  "heif": "1.12.0",
+  "imagequant": "2.4.1",
+  "lcms": "2.12",
+  "mozjpeg": "4.0.3",
+  "orc": "0.4.32",
+  "pango": "1.48.8",
+  "pixman": "0.40.0",
+  "png": "1.6.37",
+  "proxy-libintl": "ef9fe6d",
+  "svg": "2.51.4",
+  "spng": "0.6.3",
+  "tiff": "4.3.0",
+  "vips": "8.11.3",
+  "webp": "1.2.1",
+  "xml": "2.9.12",
+  "zlib-ng": "2.0.5"
+}

package/dist/node_modules/simple-get/.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    labels:
+      - dependency
+    versioning-strategy: increase-if-necessary
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: daily
+    labels:
+      - dependency

package/dist/node_modules/simple-get/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: ci
+'on':
+  - push
+  - pull_request
+jobs:
+  test:
+    name: Node ${{ matrix.node }} / ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+        node:
+          - '14'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm run build --if-present
+      - run: npm test

package/dist/node_modules/simple-get/README.md

@@ -1,7 +1,7 @@
-# simple-get [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
+# simple-get [![ci][ci-image]][ci-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
 
-[travis-image]: https://img.shields.io/travis/feross/simple-get/master.svg
-[travis-url]: https://travis-ci.org/feross/simple-get
+[ci-image]: https://img.shields.io/github/workflow/status/feross/simple-get/ci/master
+[ci-url]: https://github.com/feross/simple-get/actions
 [npm-image]: https://img.shields.io/npm/v/simple-get.svg
 [npm-url]: https://npmjs.org/package/simple-get
 [downloads-image]: https://img.shields.io/npm/dm/simple-get.svg
@@ -254,6 +254,20 @@ const opts = {
 get(opts, function (err, res) {})
 ```
 
+### Basic Auth
+
+```js
+const user = 'someuser'
+const pass = 'pa$$word'
+const encodedAuth = Buffer.from(`${user}:${pass}`).toString('base64')
+
+get('http://example.com', {
+  headers: {
+    authorization: `Basic ${encodedAuth}`
+  }
+})
+```
+
 ### OAuth
 
 You can use the [`oauth-1.0a`](https://github.com/ddo/oauth-1.0a) module to create