sharp 0.30.7 → 0.31.0

package/lib/resize.js

@@ -92,6 +92,13 @@ function isRotationExpected (options) {
   return (options.angle % 360) !== 0 || options.useExifOrientation === true || options.rotationAngle !== 0;
 }
 
+/**
+ * @private
+ */
+function isResizeExpected (options) {
+  return options.width !== -1 || options.height !== -1;
+}
+
 /**
  * Resize image to `width`, `height` or `width x height`.
  *
@@ -123,6 +130,9 @@ function isRotationExpected (options) {
  * - `lanczos2`: Use a [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel) with `a=2`.
  * - `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
  *
+ * Only one resize can occur per pipeline.
+ * Previous calls to `resize` in the same pipeline will be ignored.
+ *
  * @example
  * sharp(input)
  *   .resize({ width: 100 })
@@ -220,6 +230,9 @@ function isRotationExpected (options) {
  * @throws {Error} Invalid parameters
  */
 function resize (width, height, options) {
+  if (isResizeExpected(this.options)) {
+    this.options.debuglog('ignoring previous resize options');
+  }
   if (is.defined(width)) {
     if (is.object(width) && !is.defined(options)) {
       options = width;
@@ -300,6 +313,9 @@ function resize (width, height, options) {
       this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);
     }
   }
+  if (isRotationExpected(this.options) && isResizeExpected(this.options)) {
+    this.options.rotateBeforePreExtract = true;
+  }
   return this;
 }
 
@@ -412,7 +428,10 @@ function extend (extend) {
  * @throws {Error} Invalid parameters
  */
 function extract (options) {
-  const suffix = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
+  const suffix = isResizeExpected(this.options) || isRotationExpected(this.options) ? 'Post' : 'Pre';
+  if (this.options[`width${suffix}`] !== -1) {
+    this.options.debuglog('ignoring previous extract options');
+  }
   ['left', 'top', 'width', 'height'].forEach(function (name) {
     const value = options[name];
     if (is.integer(value) && value >= 0) {
@@ -422,32 +441,90 @@ function extract (options) {
     }
   }, this);
   // Ensure existing rotation occurs before pre-resize extraction
-  if (suffix === 'Pre' && isRotationExpected(this.options)) {
-    this.options.rotateBeforePreExtract = true;
+  if (isRotationExpected(this.options) && !isResizeExpected(this.options)) {
+    if (this.options.widthPre === -1 || this.options.widthPost === -1) {
+      this.options.rotateBeforePreExtract = true;
+    }
   }
   return this;
 }
 
 /**
- * Trim "boring" pixels from all edges that contain values similar to the top-left pixel.
- * Images consisting entirely of a single colour will calculate "boring" using the alpha channel, if any.
+ * Trim pixels from all edges that contain values similar to the given background colour, which defaults to that of the top-left pixel.
+ *
+ * Images with an alpha channel will use the combined bounding box of alpha and non-alpha channels.
+ *
+ * If the result of this operation would trim an image to nothing then no change is made.
  *
  * The `info` response Object, obtained from callback of `.toFile()` or `.toBuffer()`,
  * will contain `trimOffsetLeft` and `trimOffsetTop` properties.
  *
- * @param {number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
+ * @example
+ * // Trim pixels with a colour similar to that of the top-left pixel.
+ * sharp(input)
+ *   .trim()
+ *   .toFile(output, function(err, info) {
+ *     ...
+ *   });
+ * @example
+ * // Trim pixels with the exact same colour as that of the top-left pixel.
+ * sharp(input)
+ *   .trim(0)
+ *   .toFile(output, function(err, info) {
+ *     ...
+ *   });
+ * @example
+ * // Trim only pixels with a similar colour to red.
+ * sharp(input)
+ *   .trim("#FF0000")
+ *   .toFile(output, function(err, info) {
+ *     ...
+ *   });
+ * @example
+ * // Trim all "yellow-ish" pixels, being more lenient with the higher threshold.
+ * sharp(input)
+ *   .trim({
+ *     background: "yellow",
+ *     threshold: 42,
+ *   })
+ *   .toFile(output, function(err, info) {
+ *     ...
+ *   });
+ *
+ * @param {string|number|Object} trim - the specific background colour to trim, the threshold for doing so or an Object with both.
+ * @param {string|Object} [trim.background='top-left pixel'] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to that of the top-left pixel.
+ * @param {number} [trim.threshold=10] - the allowed difference from the above colour, a positive number.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function trim (threshold) {
-  if (!is.defined(threshold)) {
+function trim (trim) {
+  if (!is.defined(trim)) {
+    this.options.trimThreshold = 10;
+  } else if (is.string(trim)) {
+    this._setBackgroundColourOption('trimBackground', trim);
     this.options.trimThreshold = 10;
-  } else if (is.number(threshold) && threshold > 0) {
-    this.options.trimThreshold = threshold;
+  } else if (is.number(trim)) {
+    if (trim >= 0) {
+      this.options.trimThreshold = trim;
+    } else {
+      throw is.invalidParameterError('threshold', 'positive number', trim);
+    }
+  } else if (is.object(trim)) {
+    this._setBackgroundColourOption('trimBackground', trim.background);
+
+    if (!is.defined(trim.threshold)) {
+      this.options.trimThreshold = 10;
+    } else if (is.number(trim.threshold)) {
+      if (trim.threshold >= 0) {
+        this.options.trimThreshold = trim.threshold;
+      } else {
+        throw is.invalidParameterError('threshold', 'positive number', trim);
+      }
+    }
   } else {
-    throw is.invalidParameterError('threshold', 'number greater than zero', threshold);
+    throw is.invalidParameterError('trim', 'string, number or object', trim);
   }
-  if (this.options.trimThreshold && isRotationExpected(this.options)) {
+  if (isRotationExpected(this.options)) {
     this.options.rotateBeforePreExtract = true;
   }
   return this;

package/lib/utility.js

@@ -17,6 +17,10 @@ const sharp = require('./sharp');
  * @returns {Object}
  */
 const format = sharp.format();
+format.heif.output.alias = ['avif', 'heic'];
+format.jpeg.output.alias = ['jpe', 'jpg'];
+format.tiff.output.alias = ['tif'];
+format.jp2k.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
 
 /**
  * An Object containing the available interpolators and their proper values

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.30.7",
+  "version": "0.31.0",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -83,7 +83,9 @@
     "Chris Banks <christopher.bradley.banks@gmail.com>",
     "Ompal Singh <ompal.hitm09@gmail.com>",
     "Brodan <christopher.hranj@gmail.com",
-    "Ankur Parihar <ankur.github@gmail.com>"
+    "Ankur Parihar <ankur.github@gmail.com>",
+    "Brahim Ait elhaj <brahima@gmail.com>",
+    "Mart Jansink <m.jansink@gmail.com>"
   ],
   "scripts": {
     "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",
@@ -140,46 +142,46 @@
   "devDependencies": {
     "async": "^3.2.4",
     "cc": "^3.0.1",
-    "decompress-zip": "^0.3.3",
-    "documentation": "^13.2.5",
+    "documentation": "^14.0.0",
     "exif-reader": "^1.0.3",
+    "extract-zip": "^2.0.1",
     "icc": "^2.0.0",
     "license-checker": "^25.0.1",
     "mocha": "^10.0.0",
-    "mock-fs": "^5.1.2",
+    "mock-fs": "^5.1.4",
     "nyc": "^15.1.0",
-    "prebuild": "^11.0.3",
+    "prebuild": "^11.0.4",
     "rimraf": "^3.0.2",
     "semistandard": "^16.0.1"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.12.2",
+    "libvips": "8.13.1",
     "integrity": {
-      "darwin-arm64v8": "sha512-p46s/bbJAjkOXzPISZt9HUpG9GWjwQkYnLLRLKzsBJHLtB3X6C6Y/zXI5Hd0DOojcFkks9a0kTN+uDQ/XJY19g==",
-      "darwin-x64": "sha512-6vOHVZnvXwe6EXRsy29jdkUzBE6ElNpXUwd+m8vV7qy32AnXu7B9YemHsZ44vWviIwPZeXF6Nhd9EFLM0wWohw==",
-      "linux-arm64v8": "sha512-XwZdS63yhqLtbFtx/0eoLF/Agf5qtTrI11FMnMRpuBJWd4jHB60RAH+uzYUgoChCmKIS+AeXYMLm4d8Ns2QX8w==",
-      "linux-armv6": "sha512-Rh0Q0kqwPG2MjXWOkPCuPEyiUKFgKJYWLgS835D4MrXgdKr8Tft/eVrc2iGIxt2re30VpDiZ1h0Rby1aCZt2zw==",
-      "linux-armv7": "sha512-heTS/MsmRvu4JljINxP+vDiS9ZZfuGhr3IStb5F7Gc0/QLRhllYAg4rcO8L1eTK9sIIzG5ARvI19+YUZe7WbzA==",
-      "linux-x64": "sha512-SSWAwBFi0hx8V/h/v82tTFGKWTFv9FiCK3Timz5OExuI+sX1Ngrd0PVQaWXOThGNdel/fcD3Bz9YjSt4feBR1g==",
-      "linuxmusl-arm64v8": "sha512-Rhks+5C7p7aO6AucLT1uvzo8ohlqcqCUPgZmN+LZjsPWob/Iix3MfiDYtv/+gTvdeEfXxbCU6/YuPBwHQ7/crA==",
-      "linuxmusl-x64": "sha512-IOyjSQqpWVntqOUpCHVWuQwACwmmjdi15H8Pc+Ma1JkhPogTfVsFQWyL7DuOTD3Yr23EuYGzovUX00duOtfy/g==",
-      "win32-arm64v8": "sha512-A+Qe8Ipewtvw9ldvF6nWed2J8kphzrUE04nFeKCtNx6pfGQ/MAlCKMjt/U8VgUKNjB01zJDUW9XE0+FhGZ/UpQ==",
-      "win32-ia32": "sha512-cMrAvwFdDeAVnLJt0IPMPRKaIFhyXYGTprsM0DND9VUHE8F7dJMR44tS5YkXsGh1QNDtjKT6YuxAVUglmiXtpA==",
-      "win32-x64": "sha512-vLFIfw6aW2zABa8jpgzWDhljnE6glktrddErVyazAIoHl6BFFe/Da+LK1DbXvIYHz7fyOoKhSfCJHCiJG1Vg6w=="
+      "darwin-arm64v8": "sha512-JdpGTx67RDbvRkg3ljFvTzqoq+oBXmMdDFEp0expDYXmP5HLH+GCkikmsROlGltgfKE2KqL/qwpxTEhIwMK/3A==",
+      "darwin-x64": "sha512-0Oh4/hEDnzV+X8MiiyUQ4G/Zh/MHw9rKstfuX0P1czgaxS2hX8Pxdbzdk1oqwTOEYVEGO/hMm9ItCVZ3RVPPaA==",
+      "linux-arm64v8": "sha512-9pSlPzEojt6ue5vXfASNMhQO1YS1p4i4Wydu+bzOfMtIPSBRXbu/+y8WELbbo03Ts7pftm9KtrMHitCVdy5EXw==",
+      "linux-armv6": "sha512-sv2FqS/ggpQly7h5/+nh8txQDulolE5ptaE90PO7iwfTont8N42pudeqootWKsuf0fRmkW4M92184VfVVYCvGw==",
+      "linux-armv7": "sha512-LmQIB8FDfasK6BsFhnE7ZI3LMlxh/rF5tZRNQ/uoTbF2xrtWQqqgiZgCifJByiEM+1tR7RxwNdnjxZhWvM9WmQ==",
+      "linux-x64": "sha512-JBRf8WBnlVw/K1jpSvmeZpnGZGjeqhG2NDEiQV/hUze3zgDGwDza4oiworaQExQmKcDrc2LJKF14Nsz1qQSNJw==",
+      "linuxmusl-arm64v8": "sha512-yzUQO5isDwsRpEUxbMXBeWp0sKhWghebrSK46SUF5mvB/kq6hZ7JbRuJ2aZjE84K/HUTyuCc0kE+M3m8naOs+g==",
+      "linuxmusl-x64": "sha512-H3Vz1QaaZ6X5iEbfPST7TPFwDO01tI8dk1osLm6l4a17BWCaOMaBQlqxgTgYrtd09JJ9CvGoq5fo5j5TPxUc4Q==",
+      "win32-arm64v8": "sha512-b5Ver+uwOJhdOGqvZVM+qF2KLKcowcac/wKK5Fg0czqlSMqP/KxDF2kxw2eKXUJNgfqe4eDH1QG/yTg2pQSetQ==",
+      "win32-ia32": "sha512-h/SJ/Yfn0ce9H70vt1wS8rZ4PfHnguCCTsOGik7e6O/e2AlBQOM0mKsPIB9jSOquoCP8rP0qF6AOPOjXKnCk+w==",
+      "win32-x64": "sha512-p9qpdWdhZooPteib92Kk+qF1vvzcScxvOwdIP8muhgo/A8uDI4/mqXCpEbMBw6vjETKlS3qo2JUbVF6+0/lyWQ=="
     },
     "runtime": "napi",
-    "target": 5
+    "target": 7
   },
   "engines": {
-    "node": ">=12.13.0"
+    "node": ">=14.15.0"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"
   },
   "binary": {
     "napi_versions": [
-      5
+      7
     ]
   },
   "semistandard": {

package/src/common.cc

@@ -88,18 +88,14 @@ namespace sharp {
       descriptor->buffer = buffer.Data();
       descriptor->isBuffer = TRUE;
     }
-    descriptor->failOn = static_cast<VipsFailOn>(
-      vips_enum_from_nick(nullptr, VIPS_TYPE_FAIL_ON,
-      AttrAsStr(input, "failOn").data()));
+    descriptor->failOn = AttrAsEnum<VipsFailOn>(input, "failOn", VIPS_TYPE_FAIL_ON);
     // Density for vector-based input
     if (HasAttr(input, "density")) {
       descriptor->density = AttrAsDouble(input, "density");
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
-      descriptor->rawDepth = static_cast<VipsBandFormat>(
-        vips_enum_from_nick(nullptr, VIPS_TYPE_BAND_FORMAT,
-        AttrAsStr(input, "rawDepth").data()));
+      descriptor->rawDepth = AttrAsEnum<VipsBandFormat>(input, "rawDepth", VIPS_TYPE_BAND_FORMAT);
       descriptor->rawChannels = AttrAsUint32(input, "rawChannels");
       descriptor->rawWidth = AttrAsUint32(input, "rawWidth");
       descriptor->rawHeight = AttrAsUint32(input, "rawHeight");
@@ -133,11 +129,42 @@ namespace sharp {
         descriptor->createBackground = AttrAsVectorOfDouble(input, "createBackground");
       }
     }
+    // Create new image with text
+    if (HasAttr(input, "textValue")) {
+      descriptor->textValue = AttrAsStr(input, "textValue");
+      if (HasAttr(input, "textFont")) {
+        descriptor->textFont = AttrAsStr(input, "textFont");
+      }
+      if (HasAttr(input, "textFontfile")) {
+        descriptor->textFontfile = AttrAsStr(input, "textFontfile");
+      }
+      if (HasAttr(input, "textWidth")) {
+        descriptor->textWidth = AttrAsUint32(input, "textWidth");
+      }
+      if (HasAttr(input, "textHeight")) {
+        descriptor->textHeight = AttrAsUint32(input, "textHeight");
+      }
+      if (HasAttr(input, "textAlign")) {
+        descriptor->textAlign = AttrAsEnum<VipsAlign>(input, "textAlign", VIPS_TYPE_ALIGN);
+      }
+      if (HasAttr(input, "textJustify")) {
+        descriptor->textJustify = AttrAsBool(input, "textJustify");
+      }
+      if (HasAttr(input, "textDpi")) {
+        descriptor->textDpi = AttrAsUint32(input, "textDpi");
+      }
+      if (HasAttr(input, "textRgba")) {
+        descriptor->textRgba = AttrAsBool(input, "textRgba");
+      }
+      if (HasAttr(input, "textSpacing")) {
+        descriptor->textSpacing = AttrAsUint32(input, "textSpacing");
+      }
+    }
     // Limit input images to a given number of pixels, where pixels = width * height
     descriptor->limitInputPixels = static_cast<uint64_t>(AttrAsInt64(input, "limitInputPixels"));
     // Allow switch from random to sequential access
     descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
-    // Remove safety features and allow unlimited SVG/PNG input
+    // Remove safety features and allow unlimited input
     descriptor->unlimited = AttrAsBool(input, "unlimited");
     return descriptor;
   }
@@ -250,9 +277,9 @@ namespace sharp {
     { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
     { "VipsForeignLoadMagick7File", ImageType::MAGICK },
     { "VipsForeignLoadMagick7Buffer", ImageType::MAGICK },
-    { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
+    { "VipsForeignLoadOpenslideFile", ImageType::OPENSLIDE },
     { "VipsForeignLoadPpmFile", ImageType::PPM },
-    { "VipsForeignLoadFits", ImageType::FITS },
+    { "VipsForeignLoadFitsFile", ImageType::FITS },
     { "VipsForeignLoadOpenexr", ImageType::EXR },
     { "VipsForeignLoadVips", ImageType::VIPS },
     { "VipsForeignLoadVipsFile", ImageType::VIPS },
@@ -307,6 +334,17 @@ namespace sharp {
       imageType == ImageType::PDF;
   }
 
+  /*
+    Does this image type support removal of safety limits?
+  */
+  bool ImageTypeSupportsUnlimited(ImageType imageType) {
+    return
+      imageType == ImageType::JPEG ||
+      imageType == ImageType::PNG ||
+      imageType == ImageType::SVG ||
+      imageType == ImageType::HEIF;
+  }
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -335,7 +373,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail_on", descriptor->failOn);
-            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
+            if (descriptor->unlimited && ImageTypeSupportsUnlimited(imageType)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -366,34 +404,63 @@ namespace sharp {
         }
       }
     } else {
-      if (descriptor->createChannels > 0) {
+      int const channels = descriptor->createChannels;
+      if (channels > 0) {
         // Create new image
         if (descriptor->createNoiseType == "gaussian") {
-          int const channels = descriptor->createChannels;
-          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight);
           std::vector<VImage> bands = {};
           bands.reserve(channels);
           for (int _band = 0; _band < channels; _band++) {
-            bands.push_back(image.gaussnoise(
-              descriptor->createWidth,
-              descriptor->createHeight,
-              VImage::option()->set("mean", descriptor->createNoiseMean)->set("sigma", descriptor->createNoiseSigma)));
+            bands.push_back(VImage::gaussnoise(descriptor->createWidth, descriptor->createHeight, VImage::option()
+              ->set("mean", descriptor->createNoiseMean)
+              ->set("sigma", descriptor->createNoiseSigma)));
           }
-          image = image.bandjoin(bands);
+          image = VImage::bandjoin(bands).copy(VImage::option()->set("interpretation",
+            channels < 3 ? VIPS_INTERPRETATION_B_W: VIPS_INTERPRETATION_sRGB));
         } else {
           std::vector<double> background = {
             descriptor->createBackground[0],
             descriptor->createBackground[1],
             descriptor->createBackground[2]
           };
-          if (descriptor->createChannels == 4) {
+          if (channels == 4) {
             background.push_back(descriptor->createBackground[3]);
           }
-          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight).new_from_image(background);
+          image = VImage::new_matrix(descriptor->createWidth, descriptor->createHeight)
+            .copy(VImage::option()->set("interpretation",
+              channels < 3 ? VIPS_INTERPRETATION_B_W : VIPS_INTERPRETATION_sRGB))
+            .new_from_image(background);
         }
-        image.get_image()->Type = image.guess_interpretation();
         image = image.cast(VIPS_FORMAT_UCHAR);
         imageType = ImageType::RAW;
+      } else if (descriptor->textValue.length() > 0) {
+        // Create a new image with text
+        vips::VOption *textOptions = VImage::option()
+          ->set("align", descriptor->textAlign)
+          ->set("justify", descriptor->textJustify)
+          ->set("rgba", descriptor->textRgba)
+          ->set("spacing", descriptor->textSpacing)
+          ->set("autofit_dpi", &descriptor->textAutofitDpi);
+        if (descriptor->textWidth > 0) {
+          textOptions->set("width", descriptor->textWidth);
+        }
+        // Ignore dpi if height is set
+        if (descriptor->textWidth > 0 && descriptor->textHeight > 0) {
+          textOptions->set("height", descriptor->textHeight);
+        } else if (descriptor->textDpi > 0) {
+          textOptions->set("dpi", descriptor->textDpi);
+        }
+        if (descriptor->textFont.length() > 0) {
+          textOptions->set("font", const_cast<char*>(descriptor->textFont.data()));
+        }
+        if (descriptor->textFontfile.length() > 0) {
+          textOptions->set("fontfile", const_cast<char*>(descriptor->textFontfile.data()));
+        }
+        image = VImage::text(const_cast<char *>(descriptor->textValue.data()), textOptions);
+        if (!descriptor->textRgba) {
+          image = image.copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_B_W));
+        }
+        imageType = ImageType::RAW;
       } else {
         // From filesystem
         imageType = DetermineImageType(descriptor->file.data());
@@ -409,7 +476,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail_on", descriptor->failOn);
-            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
+            if (descriptor->unlimited && ImageTypeSupportsUnlimited(imageType)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -637,7 +704,6 @@ namespace sharp {
     Event listener for progress updates, used to detect timeout
   */
   void VipsProgressCallBack(VipsImage *im, VipsProgress *progress, int *timeout) {
-    // printf("VipsProgressCallBack progress=%d run=%d timeout=%d\n", progress->percent, progress->run, *timeout);
     if (*timeout > 0 && progress->run >= *timeout) {
       vips_image_set_kill(im, TRUE);
       vips_error("timeout", "%d%% complete", progress->percent);
@@ -794,22 +860,6 @@ namespace sharp {
     return Is16Bit(interpretation) ? 65535.0 : 255.0;
   }
 
-  /*
-    Get boolean operation type from string
-  */
-  VipsOperationBoolean GetBooleanOperation(std::string const opStr) {
-    return static_cast<VipsOperationBoolean>(
-      vips_enum_from_nick(nullptr, VIPS_TYPE_OPERATION_BOOLEAN, opStr.data()));
-  }
-
-  /*
-    Get interpretation type from string
-  */
-  VipsInterpretation GetInterpretation(std::string const typeStr) {
-    return static_cast<VipsInterpretation>(
-      vips_enum_from_nick(nullptr, VIPS_TYPE_INTERPRETATION, typeStr.data()));
-  }
-
   /*
     Convert RGBA value to another colourspace
   */
@@ -890,7 +940,7 @@ namespace sharp {
 
   std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
     Canvas canvas, bool swap, bool withoutEnlargement, bool withoutReduction) {
-    if (swap) {
+    if (swap && canvas != Canvas::IGNORE_ASPECT) {
       // Swap input width and height when requested.
       std::swap(width, height);
     }
@@ -921,9 +971,6 @@ namespace sharp {
           }
           break;
         case Canvas::IGNORE_ASPECT:
-          if (swap) {
-            std::swap(hshrink, vshrink);
-          }
           break;
       }
     } else if (targetWidth > 0) {

package/src/common.h

@@ -25,9 +25,9 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 12) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 12 && VIPS_MICRO_VERSION < 2)
-#error "libvips version 8.12.2+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 13) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 13 && VIPS_MICRO_VERSION < 1)
+#error "libvips version 8.13.1+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -71,6 +71,17 @@ namespace sharp {
     std::string createNoiseType;
     double createNoiseMean;
     double createNoiseSigma;
+    std::string textValue;
+    std::string textFont;
+    std::string textFontfile;
+    int textWidth;
+    int textHeight;
+    VipsAlign textAlign;
+    bool textJustify;
+    int textDpi;
+    bool textRgba;
+    int textSpacing;
+    int textAutofitDpi;
 
     InputDescriptor():
       buffer(nullptr),
@@ -95,7 +106,15 @@ namespace sharp {
       createHeight(0),
       createBackground{ 0.0, 0.0, 0.0, 255.0 },
       createNoiseMean(0.0),
-      createNoiseSigma(0.0) {}
+      createNoiseSigma(0.0),
+      textWidth(0),
+      textHeight(0),
+      textAlign(VIPS_ALIGN_LOW),
+      textJustify(FALSE),
+      textDpi(72),
+      textRgba(FALSE),
+      textSpacing(0),
+      textAutofitDpi(0) {}
   };
 
   // Convenience methods to access the attributes of a Napi::Object
@@ -110,6 +129,10 @@ namespace sharp {
   bool AttrAsBool(Napi::Object obj, std::string attr);
   std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr);
   std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr);
+  template <class T> T AttrAsEnum(Napi::Object obj, std::string attr, GType type) {
+    return static_cast<T>(
+      vips_enum_from_nick(nullptr, type, AttrAsStr(obj, attr).data()));
+  }
 
   // Create an InputDescriptor instance from a Napi::Object describing an input image
   InputDescriptor* CreateInputDescriptor(Napi::Object input);
@@ -183,6 +206,11 @@ namespace sharp {
   */
   bool ImageTypeSupportsPage(ImageType imageType);
 
+  /*
+    Does this image type support removal of safety limits?
+  */
+  bool ImageTypeSupportsUnlimited(ImageType imageType);
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -307,16 +335,6 @@ namespace sharp {
   */
   double MaximumImageAlpha(VipsInterpretation const interpretation);
 
-  /*
-    Get boolean operation type from string
-  */
-  VipsOperationBoolean GetBooleanOperation(std::string const opStr);
-
-  /*
-    Get interpretation type from string
-  */
-  VipsInterpretation GetInterpretation(std::string const typeStr);
-
   /*
     Convert RGBA value to another colourspace
   */

package/src/libvips/cplusplus/VConnection.cpp

@@ -31,7 +31,6 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif /*HAVE_CONFIG_H*/
-#include <vips/intl.h>
 
 #include <vips/vips8>
 

package/src/libvips/cplusplus/VError.cpp

@@ -30,7 +30,6 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif /*HAVE_CONFIG_H*/
-#include <vips/intl.h>
 
 #include <vips/vips8>
 

package/src/libvips/cplusplus/VImage.cpp

@@ -38,7 +38,6 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif /*HAVE_CONFIG_H*/
-#include <vips/intl.h>
 
 #include <vips/vips8>
 
@@ -733,7 +732,7 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 				set( "in", *this )->
 				set( "target", target ) );
 
-		g_object_get( target.get_target(), "blob", &blob, NULL );
+		g_object_get( target.get_target(), "blob", &blob, (void *) NULL );
 	}
 	else if( (operation_name = vips_foreign_find_save_buffer( filename )) ) {
 		call_option_string( operation_name, option_string,
@@ -778,6 +777,32 @@ VImage::write_to_target( const char *suffix, VTarget target,
 			set( "target", target ) );
 }
 
+VRegion
+VImage::region() const
+{
+	return VRegion::new_from_image( *this );
+}
+
+VRegion
+VImage::region( VipsRect *rect ) const
+{
+	VRegion region = VRegion::new_from_image( *this );
+
+	region.prepare( rect );
+
+	return region;
+}
+
+VRegion
+VImage::region( int left, int top, int width, int height ) const
+{
+	VRegion region = VRegion::new_from_image( *this );
+
+	region.prepare( left, top, width, height );
+
+	return region;
+}
+
 #include "vips-operators.cpp"
 
 std::vector<VImage>

package/src/libvips/cplusplus/VInterpolate.cpp

@@ -31,7 +31,6 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif /*HAVE_CONFIG_H*/
-#include <vips/intl.h>
 
 #include <vips/vips8>