@revizly/sharp 0.35.0-revizly6 → 0.35.0-revizly8

package/README.md

@@ -8,7 +8,7 @@ smaller, web-friendly JPEG, PNG, WebP, GIF and AVIF images of varying dimensions
 
 It can be used with all JavaScript runtimes
 that provide support for Node-API v9, including
-Node.js (^18.17.0 or >= 20.3.0), Deno and Bun.
+Node.js (>= 20.9.0), Deno and Bun.
 
 Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings

package/install/build.js

@@ -10,7 +10,7 @@ const {
   spawnRebuild,
 } = require('../lib/libvips');
 
-log('Attempting to build from source via node-gyp');
+log('Building from source');
 log('See https://sharp.pixelplumbing.com/install#building-from-source');
 
 try {
@@ -29,7 +29,7 @@ try {
 }
 
 if (useGlobalLibvips(log)) {
-  log(`Detected globally-installed libvips v${globalLibvipsVersion()}`);
+  log(`Found globally-installed libvips v${globalLibvipsVersion()}`);
 }
 
 const status = spawnRebuild();

package/lib/constructor.js

@@ -278,6 +278,7 @@ const Sharp = function (input, options) {
     trimBackground: [],
     trimThreshold: -1,
     trimLineArt: false,
+    trimMargin: 0,
     dilateWidth: 0,
     erodeWidth: 0,
     gamma: 0,
@@ -306,6 +307,7 @@ const Sharp = function (input, options) {
     fileOut: '',
     formatOut: 'input',
     streamOut: false,
+    typedArrayOut: false,
     keepMetadata: 0,
     withMetadataOrientation: -1,
     withMetadataDensity: 0,
@@ -313,6 +315,7 @@ const Sharp = function (input, options) {
     withExif: {},
     withExifMerge: true,
     withXmp: '',
+    withGainMap: false,
     resolveWithObject: false,
     loop: -1,
     delay: [],
@@ -348,6 +351,7 @@ const Sharp = function (input, options) {
     webpEffort: 4,
     webpMinSize: false,
     webpMixed: false,
+    webpExact: false,
     gifBitdepth: 8,
     gifEffort: 7,
     gifDither: 1,
@@ -362,7 +366,7 @@ const Sharp = function (input, options) {
     tiffPredictor: 'horizontal',
     tiffPyramid: false,
     tiffMiniswhite: false,
-    tiffBitdepth: 8,
+    tiffBitdepth: 0,
     tiffTile: false,
     tiffTileHeight: 256,
     tiffTileWidth: 256,
@@ -375,6 +379,7 @@ const Sharp = function (input, options) {
     heifEffort: 4,
     heifChromaSubsampling: '4:4:4',
     heifBitdepth: 8,
+    heifTune: 'ssim',
     jxlDistance: 1,
     jxlDecodingTier: 0,
     jxlEffort: 7,

package/lib/index.d.ts

@@ -259,7 +259,6 @@ declare namespace sharp {
          * Set the pipeline colourspace.
          * The input image will be converted to the provided colourspace at the start of the pipeline.
          * All operations will use this colourspace before converting to the output colourspace, as defined by toColourspace.
-         * This feature is experimental and has not yet been fully-tested with all operations.
          *
          * @param colourspace pipeline colourspace e.g. rgb16, scrgb, lab, grey16 ...
          * @throws {Error} Invalid parameters
@@ -470,21 +469,6 @@ declare namespace sharp {
          */
         sharpen(options?: SharpenOptions): Sharp;
 
-        /**
-         * 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.
-         * Fine-grained control over the level of sharpening in "flat" (m1) and "jagged" (m2) areas is available.
-         * @param sigma the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
-         * @param flat the level of sharpening to apply to "flat" areas. (optional, default 1.0)
-         * @param jagged the level of sharpening to apply to "jagged" areas. (optional, default 2.0)
-         * @throws {Error} Invalid parameters
-         * @returns A sharp instance that can be used to chain operations
-         *
-         * @deprecated Use the object parameter `sharpen({sigma, m1, m2, x1, y2, y3})` instead
-         */
-        sharpen(sigma?: number, flat?: number, jagged?: number): Sharp;
-
         /**
          * Apply median filter. When used without parameters the default window is 3x3.
          * @param size square mask size: size x size (optional, default 3)
@@ -693,6 +677,13 @@ declare namespace sharp {
          */
         toBuffer(options: { resolveWithObject: true }): Promise<{ data: Buffer; info: OutputInfo }>;
 
+        /**
+         * Write output to a Uint8Array backed by a transferable ArrayBuffer. JPEG, PNG, WebP, AVIF, TIFF, GIF and RAW output are supported.
+         * By default, the format will match the input image, except SVG input which becomes PNG output.
+         * @returns A promise that resolves with an object containing the Uint8Array data and an info object containing the output image format, size (bytes), width, height and channels
+         */
+        toUint8Array(): Promise<{ data: Uint8Array; info: OutputInfo }>;
+
         /**
          * Keep all EXIF metadata from the input image in the output image.
          * EXIF metadata is unsupported for TIFF output.
@@ -849,7 +840,7 @@ declare namespace sharp {
          * @returns A sharp instance that can be used to chain operations
          */
         toFormat(
-            format: keyof FormatEnum | AvailableFormatInfo,
+            format: keyof FormatEnum | AvailableFormatInfo | "avif",
             options?:
                 | OutputOptions
                 | JpegOptions
@@ -903,7 +894,7 @@ declare namespace sharp {
          *  - 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. Some of these values are based on the object-position CSS property.
          *
-         * The experimental strategy-based approach resizes so one dimension is at its target length then repeatedly ranks edge regions,
+         * The strategy-based approach resizes so one dimension is at its target length then repeatedly ranks edge regions,
          * discarding the edge with the lowest score based on the selected strategy.
          *  - entropy: focus on the region with the highest Shannon entropy.
          *  - attention: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
@@ -992,14 +983,6 @@ declare namespace sharp {
          *  'none' (least), 'truncated', 'error' or 'warning' (most), highers level imply lower levels, invalid metadata will always abort. (optional, default 'warning')
          */
         failOn?: FailOnOptions | undefined;
-        /**
-         * By default halt processing and raise an error when loading invalid images.
-         * Set this flag to false if you'd rather apply a "best effort" to decode images,
-         * even if the data is corrupt or invalid. (optional, default true)
-         *
-         * @deprecated Use `failOn` instead
-         */
-        failOnError?: boolean | undefined;
         /**
          * 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.
@@ -1184,6 +1167,8 @@ declare namespace sharp {
 
     type HeifCompression = 'av1' | 'hevc';
 
+    type HeifTune = 'iq' | 'ssim' | 'psnr';
+
     type Unit = 'inch' | 'cm';
 
     interface WriteableMetadata {
@@ -1277,6 +1262,8 @@ declare namespace sharp {
         formatMagick?: string | undefined;
         /** Array of keyword/text pairs representing PNG text blocks, if present. */
         comments?: CommentsMetadata[] | undefined;
+        /** HDR gain map, if present */
+        gainMap?: GainMapMetadata | undefined;
     }
 
     interface LevelMetadata {
@@ -1289,16 +1276,21 @@ declare namespace sharp {
         text: string;
     }
 
+    interface GainMapMetadata {
+        /** JPEG image */
+        image: Buffer;
+    }
+
     interface Stats {
         /** Array of channel statistics for each channel in the image. */
         channels: ChannelStats[];
         /** Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel */
         isOpaque: boolean;
-        /** Histogram-based estimation of greyscale entropy, discarding alpha channel if any (experimental) */
+        /** Histogram-based estimation of greyscale entropy, discarding alpha channel if any */
         entropy: number;
-        /** Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any (experimental) */
+        /** Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any */
         sharpness: number;
-        /** Object containing most dominant sRGB colour based on a 4096-bin 3D histogram (experimental) */
+        /** Object containing most dominant sRGB colour based on a 4096-bin 3D histogram */
         dominant: { r: number; g: number; b: number };
     }
 
@@ -1404,11 +1396,13 @@ declare namespace sharp {
         /** Level of CPU effort to reduce file size, integer 0-6 (optional, default 4) */
         effort?: number | undefined;
         /** Prevent use of animation key frames to minimise file size (slow) (optional, default false) */
-        minSize?: boolean;
+        minSize?: boolean | undefined;
         /** Allow mixture of lossy and lossless animation frames (slow) (optional, default false) */
-        mixed?: boolean;
+        mixed?: boolean | undefined;
         /** Preset options: one of default, photo, picture, drawing, icon, text (optional, default 'default') */
         preset?: keyof PresetEnum | undefined;
+        /** Preserve the colour data in transparent pixels (optional, default false) */
+        exact?: boolean | undefined;
     }
 
     interface AvifOptions extends OutputOptions {
@@ -1422,6 +1416,8 @@ declare namespace sharp {
         chromaSubsampling?: string | undefined;
         /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
         bitdepth?: 8 | 10 | 12 | undefined;
+        /** Tune output for a quality metric, one of 'iq', 'ssim' or 'psnr' (optional, default 'iq') */
+        tune?: HeifTune | undefined;
     }
 
     interface HeifOptions extends OutputOptions {
@@ -1437,6 +1433,8 @@ declare namespace sharp {
         chromaSubsampling?: string | undefined;
         /** Set bitdepth to 8, 10 or 12 bit (optional, default 8) */
         bitdepth?: 8 | 10 | 12 | undefined;
+        /** Tune output for a quality metric, one of 'ssim', 'psnr' or 'iq' (optional, default 'ssim') */
+        tune?: HeifTune | undefined;
     }
 
     interface GifOptions extends OutputOptions, AnimationOptions {
@@ -1481,8 +1479,8 @@ declare namespace sharp {
         xres?: number | undefined;
         /** Vertical resolution in pixels/mm (optional, default 1.0) */
         yres?: number | undefined;
-        /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 8) */
-        bitdepth?: 1 | 2 | 4 | 8 | undefined;
+        /** Reduce bitdepth to 1, 2 or 4 bit (optional) */
+        bitdepth?: 1 | 2 | 4 | undefined;
         /** Write 1-bit images as miniswhite (optional, default false) */
         miniswhite?: boolean | undefined;
         /** Resolution unit options: inch, cm (optional, default 'inch') */
@@ -1608,6 +1606,8 @@ declare namespace sharp {
         threshold?: number | undefined;
         /** Does the input more closely resemble line art (e.g. vector) rather than being photographic? (optional, default false) */
         lineArt?: boolean | undefined;
+        /** Leave a margin around trimmed content, value is in pixels. (optional, default 0) */
+        margin?: number | undefined;
     }
 
     interface RawOptions {
@@ -1913,16 +1913,13 @@ declare namespace sharp {
     }
 
     interface FormatEnum {
-        avif: AvailableFormatInfo;
         dcraw: AvailableFormatInfo;
         dz: AvailableFormatInfo;
         exr: AvailableFormatInfo;
         fits: AvailableFormatInfo;
         gif: AvailableFormatInfo;
         heif: AvailableFormatInfo;
-        input: AvailableFormatInfo;
         jpeg: AvailableFormatInfo;
-        jpg: AvailableFormatInfo;
         jp2: AvailableFormatInfo;
         jxl: AvailableFormatInfo;
         magick: AvailableFormatInfo;
@@ -1934,8 +1931,7 @@ declare namespace sharp {
         raw: AvailableFormatInfo;
         svg: AvailableFormatInfo;
         tiff: AvailableFormatInfo;
-        tif: AvailableFormatInfo;
-        v: AvailableFormatInfo;
+        vips: AvailableFormatInfo;
         webp: AvailableFormatInfo;
     }
 

package/lib/input.js

@@ -30,7 +30,7 @@ const inputStreamParameters = [
   // Format-specific
   'jp2', 'openSlide', 'pdf', 'raw', 'svg', 'tiff',
   // Deprecated
-  'failOnError', 'openSlideLevel', 'pdfBackground', 'tiffSubifd'
+  'openSlideLevel', 'pdfBackground', 'tiffSubifd'
 ];
 
 /**
@@ -106,14 +106,6 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }`);
   }
   if (is.object(inputOptions)) {
-    // Deprecated: failOnError
-    if (is.defined(inputOptions.failOnError)) {
-      if (is.bool(inputOptions.failOnError)) {
-        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
-      } else {
-        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
-      }
-    }
     // failOn
     if (is.defined(inputOptions.failOn)) {
       if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
@@ -575,6 +567,7 @@ function _isStreamInput () {
  * A `Promise` is returned when `callback` is not provided.
  *
  * - `format`: Name of decoder used to parse image e.g. `jpeg`, `png`, `webp`, `gif`, `svg`, `heif`, `tiff`
+ * - `mediaType`: Media Type (MIME Type) e.g. `image/jpeg`, `image/png`, `image/svg+xml`, `image/avif`
  * - `size`: Total size of image in bytes, for Stream and Buffer input only
  * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration, see example below)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
@@ -607,6 +600,7 @@ function _isStreamInput () {
  * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
  * - `formatMagick`: String containing format for images loaded via *magick
  * - `comments`: Array of keyword/text pairs representing PNG text blocks, if present.
+ * - `gainMap.image`: HDR gain map, if present, as compressed JPEG image.
  *
  * @example
  * const metadata = await sharp(input).metadata();

package/lib/operation.js

@@ -259,45 +259,18 @@ function affine (matrix, options) {
  *   })
  *   .toBuffer();
  *
- * @param {Object|number} [options] - if present, is an Object with attributes
+ * @param {Object} [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 10
  * @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}
  * @throws {Error} Invalid parameters
  */
-function sharpen (options, flat, jagged) {
-  if (!is.defined(options)) {
-    // No arguments: default to mild sharpen
-    this.options.sharpenSigma = -1;
-  } else if (is.bool(options)) {
-    // Deprecated boolean argument: apply mild sharpen?
-    this.options.sharpenSigma = options ? -1 : 0;
-  } else if (is.number(options) && is.inRange(options, 0.01, 10000)) {
-    // Deprecated numeric argument: specific sigma
-    this.options.sharpenSigma = options;
-    // Deprecated control over flat areas
-    if (is.defined(flat)) {
-      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
-        this.options.sharpenM1 = flat;
-      } else {
-        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
-      }
-    }
-    // Deprecated control over jagged areas
-    if (is.defined(jagged)) {
-      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
-        this.options.sharpenM2 = jagged;
-      } else {
-        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
-      }
-    }
-  } else if (is.plainObject(options)) {
+function sharpen (options) {
+  if (is.plainObject(options)) {
     if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10)) {
       this.options.sharpenSigma = options.sigma;
     } else {
@@ -339,7 +312,7 @@ function sharpen (options, flat, jagged) {
       }
     }
   } else {
-    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
+    this.options.sharpenSigma = -1;
   }
   return this;
 }
@@ -510,8 +483,6 @@ function flatten (options) {
  *
  * Existing alpha channel values for non-white pixels remain unchanged.
  *
- * This feature is experimental and the API may change.
- *
  * @since 0.32.1
  *
  * @example

package/lib/output.js

@@ -76,7 +76,7 @@ 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(path.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+  } else if (jp2Regex.test(path.extname(fileOut)) && !this.constructor.format.jp2.output.file) {
     err = errJp2Save();
   }
   if (err) {
@@ -164,6 +164,41 @@ function toBuffer (options, callback) {
   return this._pipeline(is.fn(options) ? options : callback, stack);
 }
 
+/**
+ * Write output to a `Uint8Array` backed by a transferable `ArrayBuffer`.
+ * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
+ *
+ * Use {@link #toformat toFormat} or one of the format-specific functions such as {@link #jpeg jpeg}, {@link #png png} etc. to set the output format.
+ *
+ * If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
+ *
+ * By default all metadata will be removed, which includes EXIF-based orientation.
+ * See {@link #keepexif keepExif} and similar methods for control over this.
+ *
+ * Resolves with an `Object` containing:
+ * - `data` is the output image as a `Uint8Array` backed by a transferable `ArrayBuffer`.
+ * - `info` contains properties relating to the output image such as `width` and `height`.
+ *
+ * @since v0.35.0
+ *
+ * @example
+ * const { data, info } = await sharp(input).toUint8Array();
+ *
+ * @example
+ * const { data } = await sharp(input)
+ *   .avif()
+ *   .toUint8Array();
+ * const base64String = data.toBase64();
+ *
+ * @returns {Promise<{ data: Uint8Array, info: Object }>}
+ */
+function toUint8Array () {
+  this.options.resolveWithObject = true;
+  this.options.typedArrayOut = true;
+  const stack = Error();
+  return this._pipeline(null, stack);
+}
+
 /**
  * Keep all EXIF metadata from the input image in the output image.
  *
@@ -319,6 +354,30 @@ function withIccProfile (icc, options) {
   return this;
 }
 
+/**
+ * If the input contains gain map metadata, use it to convert the main image to HDR (High Dynamic Range) before further processing.
+ * The input gain map is discarded.
+ *
+ * If the output is JPEG, generate and attach a new ISO 21496-1 gain map.
+ * JPEG output options other than `quality` are ignored.
+ *
+ * This feature is experimental and the API may change.
+ *
+ * @since 0.35.0
+ *
+ * @example
+ * const outputWithGainMap = await sharp(inputWithGainMap)
+ *   .withGainMap()
+ *   .toBuffer();
+ *
+ * @returns {Sharp}
+ */
+function withGainMap() {
+  this.options.withGainMap = true;
+  this.options.colourspace = 'scrgb';
+  return this;
+}
+
 /**
  * Keep XMP metadata from the input image in the output image.
  *
@@ -690,6 +749,7 @@ function png (options) {
  * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.minSize=false] - prevent use of animation key frames to minimise file size (slow)
  * @param {boolean} [options.mixed=false] - allow mixture of lossy and lossless animation frames (slow)
+ * @param {boolean} [options.exact=false] - preserve the colour data in transparent pixels
  * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -742,6 +802,9 @@ function webp (options) {
     if (is.defined(options.mixed)) {
       this._setBooleanOption('webpMixed', options.mixed);
     }
+    if (is.defined(options.exact)) {
+      this._setBooleanOption('webpExact', options.exact);
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('webp', options);
@@ -887,7 +950,7 @@ function gif (options) {
  */
 function jp2 (options) {
   /* node:coverage ignore next 41 */
-  if (!this.constructor.format.jp2k.output.buffer) {
+  if (!this.constructor.format.jp2.output.buffer) {
     throw errJp2Save();
   }
   if (is.object(options)) {
@@ -992,7 +1055,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
  * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
- * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit
  * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -1007,10 +1070,10 @@ function tiff (options) {
       }
     }
     if (is.defined(options.bitdepth)) {
-      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {
+      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4])) {
         this.options.tiffBitdepth = options.bitdepth;
       } else {
-        throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);
+        throw is.invalidParameterError('bitdepth', '1, 2 or 4', options.bitdepth);
       }
     }
     // tiling
@@ -1092,8 +1155,7 @@ function tiff (options) {
  * AVIF image sequences are not supported.
  * Prebuilt binaries support a bitdepth of 8 only.
  *
- * This feature is experimental on the Windows ARM64 platform
- * and requires a CPU with ARM64v8.4 or later.
+ * When using Windows ARM64, this feature requires a CPU with ARM64v8.4 or later.
  *
  * @example
  * const data = await sharp(input)
@@ -1113,11 +1175,13 @@ function tiff (options) {
  * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
  * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
+ * @param {string} [options.tune='iq'] - tune output for a quality metric, one of 'iq' (default), 'ssim' (default when lossless) or 'psnr'
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
 function avif (options) {
-  return this.heif({ ...options, compression: 'av1' });
+  const tune = is.object(options) && is.defined(options.tune) ? options.tune : 'iq';
+  return this.heif({ ...options, compression: 'av1', tune });
 }
 
 /**
@@ -1140,6 +1204,7 @@ function avif (options) {
  * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
  * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
+ * @param {string} [options.tune='ssim'] - tune output for a quality metric, one of 'ssim' (default), 'psnr' or 'iq'
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -1188,6 +1253,17 @@ function heif (options) {
         throw is.invalidParameterError('bitdepth', '8, 10 or 12', options.bitdepth);
       }
     }
+    if (is.defined(options.tune)) {
+      if (is.string(options.tune) && is.inArray(options.tune, ['iq', 'ssim', 'psnr'])) {
+        if (this.options.heifLossless && options.tune === 'iq') {
+          this.options.heifTune = 'ssim';
+        } else {
+          this.options.heifTune = options.tune;
+        }
+      } else {
+        throw is.invalidParameterError('tune', 'one of: psnr, ssim, iq', options.tune);
+      }
+    }
   } else {
     throw is.invalidParameterError('options', 'Object', options);
   }
@@ -1635,11 +1711,13 @@ module.exports = (Sharp) => {
     // Public
     toFile,
     toBuffer,
+    toUint8Array,
     keepExif,
     withExif,
     withExifMerge,
     keepIccProfile,
     withIccProfile,
+    withGainMap,
     keepXmp,
     withXmp,
     keepMetadata,

package/lib/resize.js

@@ -540,10 +540,19 @@ function extract (options) {
  *   })
  *   .toBuffer();
  *
+ * @example
+ * // Trim image leaving (up to) a 10 pixel margin around the trimmed content.
+ * const output = await sharp(input)
+ *   .trim({
+ *     margin: 10
+ *   })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {string|Object} [options.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} [options.threshold=10] - Allowed difference from the above colour, a positive number.
  * @param {boolean} [options.lineArt=false] - Does the input more closely resemble line art (e.g. vector) rather than being photographic?
+ * @param {number} [options.margin=0] - Leave a margin around trimmed content, value is in pixels.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -564,6 +573,13 @@ function trim (options) {
       if (is.defined(options.lineArt)) {
         this._setBooleanOption('trimLineArt', options.lineArt);
       }
+      if (is.defined(options.margin)) {
+        if (is.integer(options.margin) && options.margin >= 0) {
+          this.options.trimMargin = options.margin;
+        } else {
+          throw is.invalidParameterError('margin', 'positive integer', options.margin);
+        }
+      }
     } else {
       throw is.invalidParameterError('trim', 'object', options);
     }

package/lib/sharp.js

@@ -7,13 +7,14 @@
 
 const { familySync, versionSync } = require('detect-libc');
 
+const { version } = require('../package.json');
 const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = require('./libvips');
 const runtimePlatform = runtimePlatformArch();
 
 const paths = [
-  `../src/build/Release/sharp-${runtimePlatform}.node`,
-  '../src/build/Release/sharp-wasm32.node',
-  `@revizly/sharp-${runtimePlatform}/sharp.node`,
+  `../src/build/Release/sharp-${runtimePlatform}-${version}.node`,
+  `../src/build/Release/sharp-wasm32-${version}.node`,
+  `@revizly/harp-${runtimePlatform}/sharp.node`,
   '@revizly/sharp-wasm32/sharp.node'
 ];
 
@@ -72,6 +73,7 @@ if (sharp) {
   } else {
     help.push(
       `- Manually install libvips >= ${minimumLibvipsVersion}`,
+      '    See https://sharp.pixelplumbing.com/install#building-from-source',
       '- Add experimental WebAssembly-based dependencies:',
       '    npm install --cpu=wasm32 sharp',
       '    npm install @revizly/sharp-wasm32'

package/lib/utility.js

@@ -24,7 +24,7 @@ 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'];
+format.jp2.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];
 
 /**
  * An Object containing the available interpolators and their proper values