sharp 0.31.1 → 0.31.3

package/install/libvips.js

@@ -138,7 +138,8 @@ try {
     const libcFamily = detectLibc.familySync();
     const libcVersion = detectLibc.versionSync();
     if (libcFamily === detectLibc.GLIBC && libcVersion && minimumGlibcVersionByArch[arch]) {
-      if (semverLessThan(`${libcVersion}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
+      const libcVersionWithoutPatch = libcVersion.split('.').slice(0, 2).join('.');
+      if (semverLessThan(`${libcVersionWithoutPatch}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
         handleError(new Error(`Use with glibc ${libcVersion} requires manual installation of libvips >= ${minimumLibvipsVersion}`));
       }
     }
@@ -167,7 +168,7 @@ try {
     } else {
       const url = distBaseUrl + tarFilename;
       libvips.log(`Downloading ${url}`);
-      simpleGet({ url: url, agent: agent() }, function (err, response) {
+      simpleGet({ url: url, agent: agent(libvips.log) }, function (err, response) {
         if (err) {
           fail(err);
         } else if (response.statusCode === 404) {

package/lib/agent.js

@@ -18,7 +18,7 @@ function env (key) {
   return process.env[key];
 }
 
-module.exports = function () {
+module.exports = function (log) {
   try {
     const proxy = new url.URL(proxies.map(env).find(is.string));
     const tunnel = proxy.protocol === 'https:'
@@ -27,6 +27,7 @@ module.exports = function () {
     const proxyAuth = proxy.username && proxy.password
       ? `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`
       : null;
+    log(`Via proxy ${proxy.protocol}://${proxy.hostname}:${proxy.port} ${proxyAuth ? 'with' : 'no'} credentials`);
     return tunnel({
       proxy: {
         port: Number(proxy.port),

package/lib/channel.js

@@ -98,7 +98,7 @@ function extractChannel (channel) {
   } else {
     throw is.invalidParameterError('channel', 'integer or one of: red, green, blue, alpha', channel);
   }
-  return this.toColourspace('b-w');
+  return this;
 }
 
 /**

package/lib/constructor.js

@@ -119,7 +119,7 @@ const debuglog = util.debuglog('sharp');
  *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
  *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
  * @param {Object} [options] - if present, is an Object with optional attributes.
- * @param {string} [options.failOn='warning'] - level of sensitivity to invalid images, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels.
+ * @param {string} [options.failOn='warning'] - when to abort processing of invalid pixel data, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels, invalid metadata will always abort.
  * @param {number|boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
  *  (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
  *  An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
@@ -289,6 +289,8 @@ const Sharp = function (input, options) {
     gifBitdepth: 8,
     gifEffort: 7,
     gifDither: 1,
+    gifInterFrameMaxError: 0,
+    gifInterPaletteMaxError: 3,
     gifReoptimise: false,
     tiffQuality: 80,
     tiffCompression: 'jpeg',
@@ -306,6 +308,10 @@ const Sharp = function (input, options) {
     heifCompression: 'av1',
     heifEffort: 4,
     heifChromaSubsampling: '4:4:4',
+    jxlDistance: 1,
+    jxlDecodingTier: 0,
+    jxlEffort: 7,
+    jxlLossless: false,
     rawDepth: 'uchar',
     tileSize: 256,
     tileOverlap: 0,

package/lib/input.js

@@ -469,7 +469,7 @@ function metadata (callback) {
   } else {
     if (this._isStreamInput()) {
       return new Promise((resolve, reject) => {
-        this.on('finish', () => {
+        const finished = () => {
           this._flattenBufferIn();
           sharp.metadata(this.options, (err, metadata) => {
             if (err) {
@@ -478,7 +478,12 @@ function metadata (callback) {
               resolve(metadata);
             }
           });
-        });
+        };
+        if (this.writableFinished) {
+          finished();
+        } else {
+          this.once('finish', finished);
+        }
       });
     } else {
       return new Promise((resolve, reject) => {

package/lib/operation.js

@@ -205,9 +205,11 @@ function affine (matrix, options) {
 
 /**
  * Sharpen the image.
+ *
  * When used without parameters, performs a fast, mild sharpen of the output image.
+ *
  * When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
- * Separate control over the level of sharpening in "flat" and "jagged" areas is available.
+ * Fine-grained control over the level of sharpening in "flat" (m1) and "jagged" (m2) areas is available.
  *
  * See {@link https://www.libvips.org/API/current/libvips-convolution.html#vips-sharpen|libvips sharpen} operation.
  *
@@ -229,13 +231,13 @@ function affine (matrix, options) {
  *   })
  *   .toBuffer();
  *
- * @param {Object|number} [options] - if present, is an Object with attributes or (deprecated) a number for `options.sigma`.
- * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
- * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas.
- * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas.
- * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged"
- * @param {number} [options.y2=10.0] - maximum amount of brightening.
- * @param {number} [options.y3=20.0] - maximum amount of darkening.
+ * @param {Object|number} [options] - if present, is an Object with attributes
+ * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`, between 0.000001 and 10000
+ * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas, between 0 and 1000000
+ * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas, between 0 and 1000000
+ * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged", between 0 and 1000000
+ * @param {number} [options.y2=10.0] - maximum amount of brightening, between 0 and 1000000
+ * @param {number} [options.y3=20.0] - maximum amount of darkening, between 0 and 1000000
  * @param {number} [flat] - (deprecated) see `options.m1`.
  * @param {number} [jagged] - (deprecated) see `options.m2`.
  * @returns {Sharp}
@@ -268,44 +270,44 @@ function sharpen (options, flat, jagged) {
       }
     }
   } else if (is.plainObject(options)) {
-    if (is.number(options.sigma) && is.inRange(options.sigma, 0.01, 10000)) {
+    if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10000)) {
       this.options.sharpenSigma = options.sigma;
     } else {
-      throw is.invalidParameterError('options.sigma', 'number between 0.01 and 10000', options.sigma);
+      throw is.invalidParameterError('options.sigma', 'number between 0.000001 and 10000', options.sigma);
     }
     if (is.defined(options.m1)) {
-      if (is.number(options.m1) && is.inRange(options.m1, 0, 10000)) {
+      if (is.number(options.m1) && is.inRange(options.m1, 0, 1000000)) {
         this.options.sharpenM1 = options.m1;
       } else {
-        throw is.invalidParameterError('options.m1', 'number between 0 and 10000', options.m1);
+        throw is.invalidParameterError('options.m1', 'number between 0 and 1000000', options.m1);
       }
     }
     if (is.defined(options.m2)) {
-      if (is.number(options.m2) && is.inRange(options.m2, 0, 10000)) {
+      if (is.number(options.m2) && is.inRange(options.m2, 0, 1000000)) {
         this.options.sharpenM2 = options.m2;
       } else {
-        throw is.invalidParameterError('options.m2', 'number between 0 and 10000', options.m2);
+        throw is.invalidParameterError('options.m2', 'number between 0 and 1000000', options.m2);
       }
     }
     if (is.defined(options.x1)) {
-      if (is.number(options.x1) && is.inRange(options.x1, 0, 10000)) {
+      if (is.number(options.x1) && is.inRange(options.x1, 0, 1000000)) {
         this.options.sharpenX1 = options.x1;
       } else {
-        throw is.invalidParameterError('options.x1', 'number between 0 and 10000', options.x1);
+        throw is.invalidParameterError('options.x1', 'number between 0 and 1000000', options.x1);
       }
     }
     if (is.defined(options.y2)) {
-      if (is.number(options.y2) && is.inRange(options.y2, 0, 10000)) {
+      if (is.number(options.y2) && is.inRange(options.y2, 0, 1000000)) {
         this.options.sharpenY2 = options.y2;
       } else {
-        throw is.invalidParameterError('options.y2', 'number between 0 and 10000', options.y2);
+        throw is.invalidParameterError('options.y2', 'number between 0 and 1000000', options.y2);
       }
     }
     if (is.defined(options.y3)) {
-      if (is.number(options.y3) && is.inRange(options.y3, 0, 10000)) {
+      if (is.number(options.y3) && is.inRange(options.y3, 0, 1000000)) {
         this.options.sharpenY3 = options.y3;
       } else {
-        throw is.invalidParameterError('options.y3', 'number between 0 and 10000', options.y3);
+        throw is.invalidParameterError('options.y3', 'number between 0 and 1000000', options.y3);
       }
     }
   } else {

package/lib/output.js

@@ -22,10 +22,13 @@ const formats = new Map([
   ['jp2', 'jp2'],
   ['jpx', 'jp2'],
   ['j2k', 'jp2'],
-  ['j2c', 'jp2']
+  ['j2c', 'jp2'],
+  ['jxl', 'jxl']
 ]);
 
-const errJp2Save = new Error('JP2 output requires libvips with support for OpenJPEG');
+const jp2Regex = /\.jp[2x]|j2[kc]$/i;
+
+const errJp2Save = () => new Error('JP2 output requires libvips with support for OpenJPEG');
 
 const bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));
 
@@ -68,6 +71,8 @@ function toFile (fileOut, callback) {
     err = new Error('Missing output file path');
   } else if (is.string(this.options.input.file) && path.resolve(this.options.input.file) === path.resolve(fileOut)) {
     err = new Error('Cannot use same file for input and output');
+  } else if (jp2Regex.test(fileOut) && !this.constructor.format.jp2k.output.file) {
+    err = errJp2Save();
   }
   if (err) {
     if (is.fn(callback)) {
@@ -547,6 +552,12 @@ function webp (options) {
  *   .gif({ dither: 0 })
  *   .toBuffer();
  *
+ * @example
+ * // Lossy file size reduction of animated GIF
+ * await sharp('in.gif', { animated: true })
+ *   .gif({ interFrameMaxError: 8 })
+ *   .toFile('optim.gif');
+ *
  * @param {Object} [options] - output options
  * @param {boolean} [options.reoptimise=false] - always generate new palettes (slow), re-use existing by default
  * @param {boolean} [options.reoptimize=false] - alternative spelling of `options.reoptimise`
@@ -554,6 +565,8 @@ function webp (options) {
  * @param {number} [options.colors=256] - alternative spelling of `options.colours`
  * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest)
  * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most)
+ * @param {number} [options.interFrameMaxError=0] - maximum inter-frame error for transparency, between 0 (lossless) and 32
+ * @param {number} [options.interPaletteMaxError=3] - maximum inter-palette error for palette reuse, between 0 and 256
  * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
  * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.force=true] - force GIF output, otherwise attempt to use input format
@@ -589,6 +602,20 @@ function gif (options) {
         throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
       }
     }
+    if (is.defined(options.interFrameMaxError)) {
+      if (is.number(options.interFrameMaxError) && is.inRange(options.interFrameMaxError, 0, 32)) {
+        this.options.gifInterFrameMaxError = options.interFrameMaxError;
+      } else {
+        throw is.invalidParameterError('interFrameMaxError', 'number between 0.0 and 32.0', options.interFrameMaxError);
+      }
+    }
+    if (is.defined(options.interPaletteMaxError)) {
+      if (is.number(options.interPaletteMaxError) && is.inRange(options.interPaletteMaxError, 0, 256)) {
+        this.options.gifInterPaletteMaxError = options.interPaletteMaxError;
+      } else {
+        throw is.invalidParameterError('interPaletteMaxError', 'number between 0.0 and 256.0', options.interPaletteMaxError);
+      }
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('gif', options);
@@ -630,7 +657,7 @@ function gif (options) {
 /* istanbul ignore next */
 function jp2 (options) {
   if (!this.constructor.format.jp2k.output.buffer) {
-    throw errJp2Save;
+    throw errJp2Save();
   }
   if (is.object(options)) {
     if (is.defined(options.quality)) {
@@ -912,6 +939,71 @@ function heif (options) {
   return this._updateFormatOut('heif', options);
 }
 
+/**
+ * Use these JPEG-XL (JXL) options for output image.
+ *
+ * This feature is experimental, please do not use in production systems.
+ *
+ * Requires libvips compiled with support for libjxl.
+ * The prebuilt binaries do not include this - see
+ * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ *
+ * Image metadata (EXIF, XMP) is unsupported.
+ *
+ * @since 0.31.3
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.distance=1.0] - maximum encoding error, between 0 (highest quality) and 15 (lowest quality)
+ * @param {number} [options.quality] - calculate `distance` based on JPEG-like quality, between 1 and 100, overrides distance if specified
+ * @param {number} [options.decodingTier=0] - target decode speed tier, between 0 (highest quality) and 4 (lowest quality)
+ * @param {boolean} [options.lossless=false] - use lossless compression
+ * @param {number} [options.effort=7] - CPU effort, between 3 (fastest) and 9 (slowest)
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+function jxl (options) {
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        // https://github.com/libjxl/libjxl/blob/0aeea7f180bafd6893c1db8072dcb67d2aa5b03d/tools/cjxl_main.cc#L640-L644
+        this.options.jxlDistance = options.quality >= 30
+          ? 0.1 + (100 - options.quality) * 0.09
+          : 53 / 3000 * options.quality * options.quality - 23 / 20 * options.quality + 25;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    } else if (is.defined(options.distance)) {
+      if (is.number(options.distance) && is.inRange(options.distance, 0, 15)) {
+        this.options.jxlDistance = options.distance;
+      } else {
+        throw is.invalidParameterError('distance', 'number between 0.0 and 15.0', options.distance);
+      }
+    }
+    if (is.defined(options.decodingTier)) {
+      if (is.integer(options.decodingTier) && is.inRange(options.decodingTier, 0, 4)) {
+        this.options.jxlDecodingTier = options.decodingTier;
+      } else {
+        throw is.invalidParameterError('decodingTier', 'integer between 0 and 4', options.decodingTier);
+      }
+    }
+    if (is.defined(options.lossless)) {
+      if (is.bool(options.lossless)) {
+        this.options.jxlLossless = options.lossless;
+      } else {
+        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
+      }
+    }
+    if (is.defined(options.effort)) {
+      if (is.integer(options.effort) && is.inRange(options.effort, 3, 9)) {
+        this.options.jxlEffort = options.effort;
+      } else {
+        throw is.invalidParameterError('effort', 'integer between 3 and 9', options.effort);
+      }
+    }
+  }
+  return this._updateFormatOut('jxl', options);
+}
+
 /**
  * Force output to be raw, uncompressed pixel data.
  * Pixel ordering is left-to-right, top-to-bottom, without padding.
@@ -1282,6 +1374,7 @@ module.exports = function (Sharp) {
     tiff,
     avif,
     heif,
+    jxl,
     gif,
     raw,
     tile,

package/lib/resize.js

@@ -111,7 +111,9 @@ function isResizeExpected (options) {
  *
  * Some of these values are based on the [object-fit](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) CSS property.
  *
- * When using a `fit` of `cover` or `contain`, the default **position** is `centre`. Other options are:
+ * <img alt="Examples of various values for the fit property when resizing" width="100%" style="aspect-ratio: 998/243" src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/image/api-resize-fit.png">
+ *
+ * When using a **fit** of `cover` or `contain`, the default **position** is `centre`. Other options are:
  * - `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
  * - `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
  * - `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
@@ -217,8 +219,8 @@ function isResizeExpected (options) {
  * @param {number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
  * @param {number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
  * @param {Object} [options]
- * @param {String} [options.width] - alternative means of specifying `width`. If both are present this take priority.
- * @param {String} [options.height] - alternative means of specifying `height`. If both are present this take priority.
+ * @param {String} [options.width] - alternative means of specifying `width`. If both are present this takes priority.
+ * @param {String} [options.height] - alternative means of specifying `height`. If both are present this takes priority.
  * @param {String} [options.fit='cover'] - how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`.
  * @param {String} [options.position='centre'] - 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.

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.31.1",
+  "version": "0.31.3",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -92,7 +92,7 @@
     "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
     "test": "npm run test-lint && npm run test-unit && npm run test-licensing",
     "test-lint": "semistandard && cpplint",
-    "test-unit": "nyc --reporter=lcov --reporter=text --check-coverage --branches=100 mocha --slow=1000 --timeout=20000 ./test/unit/*.js",
+    "test-unit": "nyc --reporter=lcov --reporter=text --check-coverage --branches=100 mocha",
     "test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
     "test-leak": "./test/leak/leak.sh",
     "docs-build": "documentation lint lib && node docs/build && node docs/search-index/build",
@@ -133,7 +133,7 @@
     "detect-libc": "^2.0.1",
     "node-addon-api": "^5.0.0",
     "prebuild-install": "^7.1.1",
-    "semver": "^7.3.7",
+    "semver": "^7.3.8",
     "simple-get": "^4.0.1",
     "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
@@ -141,13 +141,13 @@
   "devDependencies": {
     "async": "^3.2.4",
     "cc": "^3.0.1",
-    "documentation": "^14.0.0",
+    "documentation": "^14.0.1",
     "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.4",
+    "mocha": "^10.2.0",
+    "mock-fs": "^5.2.0",
     "nyc": "^15.1.0",
     "prebuild": "^11.0.4",
     "rimraf": "^3.0.2",
@@ -155,19 +155,19 @@
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.13.2",
+    "libvips": "8.13.3",
     "integrity": {
-      "darwin-arm64v8": "sha512-4tsE/HMQDT9srV/ovSJlr7IxKnhvH9qpArCAf5Xpb/uNcAiT7BcZ+HYwX2lbf3UY8REB1TR4ThEL/lmPnzMUHw==",
-      "darwin-x64": "sha512-D4ZSvlgLpf+KzKB2OD+K8NWl0JKzzIbvWwIjjwBycIHTMkaiams3Kp/AQ/bKudqof02Ks6LtP0X4XWvCaoRoUA==",
-      "linux-arm64v8": "sha512-9ZvUM2NBluhoeUz9X7/zJ48xJ5d7KzI1cO6lsiv4HKo5fOYw/vEY28XodFJzhyfu9NuKxh3Hs9FtoQGNvvAFkw==",
-      "linux-armv6": "sha512-vu0R8DF0k7KseU62fzrJadHNk5oeJriFLVn3KxCKEfV+Wkj7rX4lQhiPmOuD7/wRcUY+GGdoZ52vysDwMQhfzA==",
-      "linux-armv7": "sha512-UdfhJTjGFgrwc3Kaos5G1ZAK2+t/16Prtnl6FAT+m7cG5EXzYAqzgvk4qtakAH7UTnVe8MUgOfbTLt0YiRpfsg==",
-      "linux-x64": "sha512-sv92VpPyN+3oBv0vi4wDjx51demGdtyhEjd+vDfC3h8S/RSuIUE9Pt/+dBFuf+iv9tRdIq9hH9vzAvsLVy6NYg==",
-      "linuxmusl-arm64v8": "sha512-TjhK/wHAS/m55l46T8PZ0qvlK+PKYFZGTQfh+c9aG8/z1v/VtG7TQOLNmPWfg0SFDTkXV7YqnJCqvgYLmJPZUg==",
-      "linuxmusl-x64": "sha512-/su96pn/H9+lDdnlM1xB2whWEoeEDJICFp/RNRJb0+bJPJhnL/IDVIhF4VnVNBq/9AlldBWii3hqMq5rY2eEAA==",
-      "win32-arm64v8": "sha512-UnSmwCcx3F5u4UOXyrdwTdYsuMK/RtQYc+1y+QxqIkBHiSL7dOlTIH/vKOSQvSaDQTPqxVLFt3wkMN1U7LZwyg==",
-      "win32-ia32": "sha512-KH/H6vpx5lJ6NEzLQmwxU/QnDg8p1Jxd+WKaPiyWmXq/HpwyKrZhi3WDoyKD4fLwnlfhAXEfVLZbUbhX21pDpQ==",
-      "win32-x64": "sha512-Xim5F21pqx7MuVQViaQNhSz24zWIiKHC9bm4KCdi7q/ytbvdMhm6bzWDI/mvFGNjI62NRB2SBkTTaqwJvM/pUg=="
+      "darwin-arm64v8": "sha512-xFgYt7CtQSZcWoyUdzPTDNHbioZIrZSEU+gkMxzH4Cgjhi4/N49UsonnIZhKQoTBGloAqEexHeMx4rYTQ2Kgvw==",
+      "darwin-x64": "sha512-6SivWKzu15aUMMohe0wg7sNYMPETVnOe40BuWsnKOgzl3o5FpQqNSgs+68Mi8Za3Qti9/DaR+H/fyD0x48Af2w==",
+      "linux-arm64v8": "sha512-b+iI9V/ehgDabXYRQcvqa5CEysh+1FQsgFmYc358StCrJCDahwNmsQdsiH1GOVd5WaWh5wHUGByPwMmFOO16Aw==",
+      "linux-armv6": "sha512-zRP2F+EiustLE4bXSH8AHCxwfemh9d+QuvmPjira/HL6uJOUuA7SyQgVV1TPwTQle2ioCNnKPm7FEB/MAiT+ug==",
+      "linux-armv7": "sha512-6OCChowE5lBXXXAZrnGdA9dVktg7UdODEBpE5qTroiAJYZv4yXRMgyDFYajok7du2NTgoklhxGk8d9+4vGv5hg==",
+      "linux-x64": "sha512-OTmlmP2r8ozGKdB96X+K5oQE1ojVZanqLqqKlwDpEnfixyIaDGYbVzcjWBNGU3ai/26bvkaCkjynnc2ecYcsuA==",
+      "linuxmusl-arm64v8": "sha512-Qh5Wi+bkKTohFYHzSPssfjMhIkD6z6EHbVmnwmWSsgY9zsUBStFp6+mKcNTQfP5YM5Mz06vJOkLHX2OzEr5TzA==",
+      "linuxmusl-x64": "sha512-DwB4Fs3+ISw9etaLCANkueZDdk758iOS+wNp4TKZkHdq0al6B/3Pk7OHLR8a9E3H6wYDD328u++dcJzip5tacA==",
+      "win32-arm64v8": "sha512-96r3W+O4BtX602B1MtxU5Ru4lKzRRTZqM4OQEBJ//TNL3fiCZdd9agD+RQBjaeR4KFIyBSt3F7IE425ZWmxz+w==",
+      "win32-ia32": "sha512-qfN1MsfQGek1QQd1UNW7JT+5K5Ne1suFQ2GpgpYm3JLSpIve/tz2vOGEGzvTVssOBADJvAkTDFt+yIi3PgU9pA==",
+      "win32-x64": "sha512-eb3aAmjbVVBVRbiYgebQwoxkAt69WI8nwmKlilSQ3kWqoc0pXfIe322rF2UR8ebbISCGvYRUfzD2r1k92RXISQ=="
     },
     "runtime": "napi",
     "target": 7

package/src/common.cc

@@ -76,6 +76,14 @@ namespace sharp {
     }
     return vector;
   }
+  Napi::Buffer<char> NewOrCopyBuffer(Napi::Env env, char* data, size_t len) {
+    try {
+      return Napi::Buffer<char>::New(env, data, len, FreeCallback);
+    } catch (Napi::Error const &err) {}
+    Napi::Buffer<char> buf = Napi::Buffer<char>::Copy(env, data, len);
+    FreeCallback(nullptr, data);
+    return buf;
+  }
 
   // Create an InputDescriptor instance from a Napi::Object describing an input image
   InputDescriptor* CreateInputDescriptor(Napi::Object input) {
@@ -207,6 +215,9 @@ namespace sharp {
   bool IsAvif(std::string const &str) {
     return EndsWith(str, ".avif") || EndsWith(str, ".AVIF");
   }
+  bool IsJxl(std::string const &str) {
+    return EndsWith(str, ".jxl") || EndsWith(str, ".JXL");
+  }
   bool IsDz(std::string const &str) {
     return EndsWith(str, ".dzi") || EndsWith(str, ".DZI");
   }
@@ -237,6 +248,7 @@ namespace sharp {
       case ImageType::PPM: id = "ppm"; break;
       case ImageType::FITS: id = "fits"; break;
       case ImageType::EXR: id = "exr"; break;
+      case ImageType::JXL: id = "jxl"; break;
       case ImageType::VIPS: id = "vips"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
@@ -281,6 +293,8 @@ namespace sharp {
     { "VipsForeignLoadPpmFile", ImageType::PPM },
     { "VipsForeignLoadFitsFile", ImageType::FITS },
     { "VipsForeignLoadOpenexr", ImageType::EXR },
+    { "VipsForeignLoadJxlFile", ImageType::JXL },
+    { "VipsForeignLoadJxlBuffer", ImageType::JXL },
     { "VipsForeignLoadVips", ImageType::VIPS },
     { "VipsForeignLoadVipsFile", ImageType::VIPS },
     { "VipsForeignLoadRaw", ImageType::RAW }
@@ -913,7 +927,7 @@ namespace sharp {
     // Add non-transparent alpha channel, if required
     if (colour[3] < 255.0 && !HasAlpha(image)) {
       image = image.bandjoin(
-        VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
+        VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier).cast(image.format()));
     }
     return std::make_tuple(image, alphaColour);
   }

package/src/common.h

@@ -26,8 +26,8 @@
 
 #if (VIPS_MAJOR_VERSION < 8) || \
   (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 13) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 13 && VIPS_MICRO_VERSION < 2)
-#error "libvips version 8.13.2+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 13 && VIPS_MICRO_VERSION < 3)
+#error "libvips version 8.13.3+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -133,6 +133,7 @@ namespace sharp {
     return static_cast<T>(
       vips_enum_from_nick(nullptr, type, AttrAsStr(obj, attr).data()));
   }
+  Napi::Buffer<char> NewOrCopyBuffer(Napi::Env env, char* data, size_t len);
 
   // Create an InputDescriptor instance from a Napi::Object describing an input image
   InputDescriptor* CreateInputDescriptor(Napi::Object input);
@@ -152,6 +153,7 @@ namespace sharp {
     PPM,
     FITS,
     EXR,
+    JXL,
     VIPS,
     RAW,
     UNKNOWN,
@@ -182,6 +184,7 @@ namespace sharp {
   bool IsHeic(std::string const &str);
   bool IsHeif(std::string const &str);
   bool IsAvif(std::string const &str);
+  bool IsJxl(std::string const &str);
   bool IsDz(std::string const &str);
   bool IsDzZip(std::string const &str);
   bool IsV(std::string const &str);

package/src/metadata.cc

@@ -235,20 +235,20 @@ class MetadataWorker : public Napi::AsyncWorker {
         info.Set("orientation", baton->orientation);
       }
       if (baton->exifLength > 0) {
-        info.Set("exif", Napi::Buffer<char>::New(env, baton->exif, baton->exifLength, sharp::FreeCallback));
+        info.Set("exif", sharp::NewOrCopyBuffer(env, baton->exif, baton->exifLength));
       }
       if (baton->iccLength > 0) {
-        info.Set("icc", Napi::Buffer<char>::New(env, baton->icc, baton->iccLength, sharp::FreeCallback));
+        info.Set("icc", sharp::NewOrCopyBuffer(env, baton->icc, baton->iccLength));
       }
       if (baton->iptcLength > 0) {
-        info.Set("iptc", Napi::Buffer<char>::New(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
+        info.Set("iptc", sharp::NewOrCopyBuffer(env, baton->iptc, baton->iptcLength));
       }
       if (baton->xmpLength > 0) {
-        info.Set("xmp", Napi::Buffer<char>::New(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
+        info.Set("xmp", sharp::NewOrCopyBuffer(env, baton->xmp, baton->xmpLength));
       }
       if (baton->tifftagPhotoshopLength > 0) {
         info.Set("tifftagPhotoshop",
-          Napi::Buffer<char>::New(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback));
+          sharp::NewOrCopyBuffer(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength));
       }
       Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
     } else {

package/src/operations.cc

@@ -345,9 +345,9 @@ namespace sharp {
     if (HasAlpha(image) && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {
       // Separate alpha channel
       VImage alpha = image[bands - 1];
-      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
+      return RemoveAlpha(image).linear(a, b, VImage::option()->set("uchar", TRUE)).bandjoin(alpha);
     } else {
-      return image.linear(a, b);
+      return image.linear(a, b, VImage::option()->set("uchar", TRUE));
     }
   }
 

package/src/pipeline.cc

@@ -81,35 +81,47 @@ class PipelineWorker : public Napi::AsyncWorker {
       int pageHeight = sharp::GetPageHeight(image);
 
       // Calculate angle of rotation
-      VipsAngle rotation;
-      bool flip = FALSE;
-      bool flop = FALSE;
+      VipsAngle rotation = VIPS_ANGLE_D0;
+      VipsAngle autoRotation = VIPS_ANGLE_D0;
+      bool autoFlip = FALSE;
+      bool autoFlop = FALSE;
       if (baton->useExifOrientation) {
         // Rotate and flip image according to Exif orientation
-        std::tie(rotation, flip, flop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
+        std::tie(autoRotation, autoFlip, autoFlop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
+        image = sharp::RemoveExifOrientation(image);
       } else {
         rotation = CalculateAngleRotation(baton->angle);
       }
 
       // Rotate pre-extract
       bool const shouldRotateBefore = baton->rotateBeforePreExtract &&
-        (rotation != VIPS_ANGLE_D0 || flip || flop || baton->rotationAngle != 0.0);
+        (rotation != VIPS_ANGLE_D0 || autoRotation != VIPS_ANGLE_D0 ||
+          autoFlip || baton->flip || autoFlop || baton->flop ||
+          baton->rotationAngle != 0.0);
 
       if (shouldRotateBefore) {
-        if (rotation != VIPS_ANGLE_D0) {
-          image = image.rot(rotation);
+        if (autoRotation != VIPS_ANGLE_D0) {
+          image = image.rot(autoRotation);
+          autoRotation = VIPS_ANGLE_D0;
         }
-        if (flip) {
+        if (autoFlip) {
+          image = image.flip(VIPS_DIRECTION_VERTICAL);
+          autoFlip = FALSE;
+        } else if (baton->flip) {
           image = image.flip(VIPS_DIRECTION_VERTICAL);
+          baton->flip = FALSE;
         }
-        if (flop) {
+        if (autoFlop) {
           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 || flip || flop) {
-          image = sharp::RemoveExifOrientation(image);
+        if (rotation != VIPS_ANGLE_D0) {
+          image = image.rot(rotation);
+          rotation = VIPS_ANGLE_D0;
         }
-        flop = FALSE;
-        flip = FALSE;
         if (baton->rotationAngle != 0.0) {
           MultiPageUnsupported(nPages, "Rotate");
           std::vector<double> background;
@@ -150,7 +162,9 @@ class PipelineWorker : public Napi::AsyncWorker {
       int targetResizeHeight = baton->height;
 
       // Swap input output width and height when rotating by 90 or 270 degrees
-      bool swap = !baton->rotateBeforePreExtract && (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270);
+      bool swap = !baton->rotateBeforePreExtract &&
+        (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270 ||
+          autoRotation == VIPS_ANGLE_D90 || autoRotation == VIPS_ANGLE_D270);
 
       // Shrink to pageHeight, so we work for multi-page images
       std::tie(hshrink, vshrink) = sharp::ResolveShrink(
@@ -367,30 +381,21 @@ class PipelineWorker : public Napi::AsyncWorker {
           ->set("kernel", baton->kernel));
       }
 
+      // Auto-rotate post-extract
+      if (autoRotation != VIPS_ANGLE_D0) {
+        image = image.rot(autoRotation);
+      }
       // Flip (mirror about Y axis)
-      if (baton->flip || flip) {
+      if (baton->flip || autoFlip) {
         image = image.flip(VIPS_DIRECTION_VERTICAL);
-        image = sharp::RemoveExifOrientation(image);
       }
-
       // Flop (mirror about X axis)
-      if (baton->flop || flop) {
+      if (baton->flop || autoFlop) {
         image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-        image = sharp::RemoveExifOrientation(image);
       }
-
       // Rotate post-extract 90-angle
-      if (!baton->rotateBeforePreExtract && rotation != VIPS_ANGLE_D0) {
+      if (rotation != VIPS_ANGLE_D0) {
         image = image.rot(rotation);
-        if (flip) {
-          image = image.flip(VIPS_DIRECTION_VERTICAL);
-          flip = FALSE;
-        }
-        if (flop) {
-          image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-          flop = FALSE;
-        }
-        image = sharp::RemoveExifOrientation(image);
       }
 
       // Join additional color channels to the image
@@ -696,24 +701,6 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::Tint(image, baton->tintA, baton->tintB);
       }
 
-      // Extract an image channel (aka vips band)
-      if (baton->extractChannel > -1) {
-        if (baton->extractChannel >= image.bands()) {
-          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
-            baton->extractChannel = image.bands() - 1;
-          } else {
-            (baton->err).append("Cannot extract channel from image. Too few channels in image.");
-            return Error();
-          }
-        }
-        VipsInterpretation const interpretation = sharp::Is16Bit(image.interpretation())
-          ? VIPS_INTERPRETATION_GREY16
-          : VIPS_INTERPRETATION_B_W;
-        image = image
-          .extract_band(baton->extractChannel)
-          .copy(VImage::option()->set("interpretation", interpretation));
-      }
-
       // Remove alpha channel, if any
       if (baton->removeAlpha) {
         image = sharp::RemoveAlpha(image);
@@ -739,6 +726,26 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
       }
 
+      // Extract channel
+      if (baton->extractChannel > -1) {
+        if (baton->extractChannel >= image.bands()) {
+          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
+            baton->extractChannel = image.bands() - 1;
+          } else {
+            (baton->err)
+              .append("Cannot extract channel ").append(std::to_string(baton->extractChannel))
+              .append(" from image with channels 0-").append(std::to_string(image.bands() - 1));
+            return Error();
+          }
+        }
+        VipsInterpretation colourspace = sharp::Is16Bit(image.interpretation())
+          ? VIPS_INTERPRETATION_GREY16
+          : VIPS_INTERPRETATION_B_W;
+        image = image
+          .extract_band(baton->extractChannel)
+          .copy(VImage::option()->set("interpretation", colourspace));
+      }
+
       // Apply output ICC profile
       if (!baton->withMetadataIcc.empty()) {
         image = image.icc_transform(
@@ -864,6 +871,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("bitdepth", baton->gifBitdepth)
             ->set("effort", baton->gifEffort)
             ->set("reoptimise", baton->gifReoptimise)
+            ->set("interframe_maxerror", baton->gifInterFrameMaxError)
+            ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
             ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -930,6 +939,21 @@ class PipelineWorker : public Napi::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "dz";
+        } else if (baton->formatOut == "jxl" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::JXL)) {
+          // Write JXL to buffer
+          image = sharp::RemoveAnimationProperties(image);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jxlsave_buffer(VImage::option()
+            ->set("strip", !baton->withMetadata)
+            ->set("distance", baton->jxlDistance)
+            ->set("tier", baton->jxlDecodingTier)
+            ->set("effort", baton->jxlEffort)
+            ->set("lossless", baton->jxlLossless)));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "jxl";
         } else if (baton->formatOut == "raw" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::RAW)) {
           // Write raw, uncompressed image data to buffer
@@ -968,6 +992,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         bool const isTiff = sharp::IsTiff(baton->fileOut);
         bool const isJp2 = sharp::IsJp2(baton->fileOut);
         bool const isHeif = sharp::IsHeif(baton->fileOut);
+        bool const isJxl = sharp::IsJxl(baton->fileOut);
         bool const isDz = sharp::IsDz(baton->fileOut);
         bool const isDzZip = sharp::IsDzZip(baton->fileOut);
         bool const isV = sharp::IsV(baton->fileOut);
@@ -1085,6 +1110,17 @@ class PipelineWorker : public Napi::AsyncWorker {
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless));
           baton->formatOut = "heif";
+        } else if (baton->formatOut == "jxl" || (mightMatchInput && isJxl) ||
+          (willMatchInput && inputImageType == sharp::ImageType::JXL)) {
+          // Write JXL to file
+          image = sharp::RemoveAnimationProperties(image);
+          image.jxlsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("strip", !baton->withMetadata)
+            ->set("distance", baton->jxlDistance)
+            ->set("tier", baton->jxlDecodingTier)
+            ->set("effort", baton->jxlEffort)
+            ->set("lossless", baton->jxlLossless));
+          baton->formatOut = "jxl";
         } else if (baton->formatOut == "dz" || isDz || isDzZip) {
           // Write DZ to file
           if (isDzZip) {
@@ -1170,8 +1206,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Add buffer size to info
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
         // Pass ownership of output data to Buffer instance
-        Napi::Buffer<char> data = Napi::Buffer<char>::New(env, static_cast<char*>(baton->bufferOut),
-          baton->bufferOutLength, sharp::FreeCallback);
+        Napi::Buffer<char> data = sharp::NewOrCopyBuffer(env, static_cast<char*>(baton->bufferOut),
+          baton->bufferOutLength);
         Callback().MakeCallback(Receiver().Value(), { env.Null(), data, info });
       } else {
         // Add file size to info
@@ -1544,6 +1580,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->gifBitdepth = sharp::AttrAsUint32(options, "gifBitdepth");
   baton->gifEffort = sharp::AttrAsUint32(options, "gifEffort");
   baton->gifDither = sharp::AttrAsDouble(options, "gifDither");
+  baton->gifInterFrameMaxError = sharp::AttrAsDouble(options, "gifInterFrameMaxError");
+  baton->gifInterPaletteMaxError = sharp::AttrAsDouble(options, "gifInterPaletteMaxError");
   baton->gifReoptimise = sharp::AttrAsBool(options, "gifReoptimise");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
@@ -1568,6 +1606,10 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     options, "heifCompression", VIPS_TYPE_FOREIGN_HEIF_COMPRESSION);
   baton->heifEffort = sharp::AttrAsUint32(options, "heifEffort");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
+  baton->jxlDistance = sharp::AttrAsDouble(options, "jxlDistance");
+  baton->jxlDecodingTier = sharp::AttrAsUint32(options, "jxlDecodingTier");
+  baton->jxlEffort = sharp::AttrAsUint32(options, "jxlEffort");
+  baton->jxlLossless = sharp::AttrAsBool(options, "jxlLossless");
   baton->rawDepth = sharp::AttrAsEnum<VipsBandFormat>(options, "rawDepth", VIPS_TYPE_BAND_FORMAT);
   // Animated output properties
   if (sharp::HasAttr(options, "loop")) {

package/src/pipeline.h

@@ -163,6 +163,8 @@ struct PipelineBaton {
   int gifBitdepth;
   int gifEffort;
   double gifDither;
+  double gifInterFrameMaxError;
+  double gifInterPaletteMaxError;
   bool gifReoptimise;
   int tiffQuality;
   VipsForeignTiffCompression tiffCompression;
@@ -180,6 +182,10 @@ struct PipelineBaton {
   int heifEffort;
   std::string heifChromaSubsampling;
   bool heifLossless;
+  double jxlDistance;
+  int jxlDecodingTier;
+  int jxlEffort;
+  bool jxlLossless;
   VipsBandFormat rawDepth;
   std::string err;
   bool withMetadata;
@@ -314,6 +320,8 @@ struct PipelineBaton {
     gifBitdepth(8),
     gifEffort(7),
     gifDither(1.0),
+    gifInterFrameMaxError(0.0),
+    gifInterPaletteMaxError(3.0),
     gifReoptimise(false),
     tiffQuality(80),
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
@@ -331,6 +339,10 @@ struct PipelineBaton {
     heifEffort(4),
     heifChromaSubsampling("4:4:4"),
     heifLossless(false),
+    jxlDistance(1.0),
+    jxlDecodingTier(0),
+    jxlEffort(7),
+    jxlLossless(false),
     rawDepth(VIPS_FORMAT_UCHAR),
     withMetadata(false),
     withMetadataOrientation(-1),

package/src/stats.cc

@@ -176,6 +176,7 @@ Napi::Value stats(const Napi::CallbackInfo& info) {
 
   // Input
   baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+  baton->input->access = VIPS_ACCESS_RANDOM;
 
   // Function to notify of libvips warnings
   Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();

package/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", "jp2k"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl"
   }) {
     // Input
     const VipsObjectClass *oc = vips_class_find("VipsOperation", (f + "load").c_str());