sharp 0.30.7 → 0.31.0

package/README.md

@@ -16,7 +16,7 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern macOS, Windows and Linux systems running Node.js >= 12.13.0
+Most modern macOS, Windows and Linux systems running Node.js >= 14.15.0
 do not require any additional install or runtime dependencies.
 
 ## Documentation

package/binding.gyp

@@ -15,10 +15,11 @@
           '_ALLOW_KEYWORD_MACROS'
         ],
         'sources': [
-          'src/libvips/cplusplus/VError.cpp',
           'src/libvips/cplusplus/VConnection.cpp',
+          'src/libvips/cplusplus/VError.cpp',
+          'src/libvips/cplusplus/VImage.cpp',
           'src/libvips/cplusplus/VInterpolate.cpp',
-          'src/libvips/cplusplus/VImage.cpp'
+          'src/libvips/cplusplus/VRegion.cpp'
         ],
         'include_dirs': [
           '<(sharp_vendor_dir)/include',
@@ -69,7 +70,7 @@
   }, {
     'target_name': 'sharp-<(platform_and_arch)',
     'defines': [
-      'NAPI_VERSION=5'
+      'NAPI_VERSION=7'
     ],
     'dependencies': [
       '<!(node -p "require(\'node-addon-api\').gyp")',

package/lib/composite.js

@@ -43,6 +43,9 @@ const blend = {
  * The images to composite must be the same size or smaller than the processed image.
  * If both `top` and `left` options are provided, they take precedence over `gravity`.
  *
+ * Any resize or rotate operations in the same processing pipeline
+ * will always be applied to the input image before composition.
+ *
  * The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
  * `dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
  * `xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
@@ -93,6 +96,17 @@ const blend = {
  * @param {Number} [images[].input.create.height]
  * @param {Number} [images[].input.create.channels] - 3-4
  * @param {String|Object} [images[].input.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [images[].input.text] - describes a new text image to be created.
+ * @param {string} [images[].input.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+ * @param {string} [images[].input.text.font] - font name to render with.
+ * @param {string} [images[].input.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
+ * @param {number} [images[].input.text.width=0] - integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
+ * @param {number} [images[].input.text.height=0] - integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
+ * @param {string} [images[].input.text.align='left'] - text alignment (`'left'`, `'centre'`, `'center'`, `'right'`).
+ * @param {boolean} [images[].input.text.justify=false] - set this to true to apply justification to the text.
+ * @param {number} [images[].input.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
+ * @param {boolean} [images[].input.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`.
+ * @param {number} [images[].input.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
  * @param {String} [images[].blend='over'] - how to blend this image with the image below.
  * @param {String} [images[].gravity='centre'] - gravity at which to place the overlay.
  * @param {Number} [images[].top] - the pixel offset from the top edge.

package/lib/constructor.js

@@ -92,6 +92,27 @@ const debuglog = util.debuglog('sharp');
  *  }
  * }).toFile('noise.png');
  *
+ * @example
+ * // Generate an image from text
+ * await sharp({
+ *   text: {
+ *     text: 'Hello, world!',
+ *     width: 400, // max width
+ *     height: 300 // max height
+ *   }
+ * }).toFile('text_bw.png');
+ *
+ * @example
+ * // Generate an rgba image from text using pango markup and font
+ * await sharp({
+ *   text: {
+ *     text: '<span foreground="red">Red!</span><span background="cyan">blue</span>',
+ *     font: 'sans',
+ *     rgba: true,
+ *     dpi: 300
+ *   }
+ * }).toFile('text_rgba.png');
+ *
  * @param {(Buffer|Uint8Array|Uint8ClampedArray|Int8Array|Uint16Array|Int16Array|Uint32Array|Int32Array|Float32Array|Float64Array|string)} [input] - if present, can be
  *  a Buffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image data, or
  *  a TypedArray containing raw pixel image data, or
@@ -102,7 +123,7 @@ const debuglog = util.debuglog('sharp');
  * @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).
- * @param {boolean} [options.unlimited=false] - Set this to `true` to remove safety features that help prevent memory exhaustion (SVG, PNG).
+ * @param {boolean} [options.unlimited=false] - Set this to `true` to remove safety features that help prevent memory exhaustion (JPEG, PNG, SVG, HEIF).
  * @param {boolean} [options.sequentialRead=false] - Set this to `true` to use sequential rather than random access where possible.
  *  This can reduce memory usage and might improve performance on some systems.
  * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
@@ -126,6 +147,17 @@ const debuglog = util.debuglog('sharp');
  * @param {string} [options.create.noise.type] - type of generated noise, currently only `gaussian` is supported.
  * @param {number} [options.create.noise.mean] - mean of pixels in generated noise.
  * @param {number} [options.create.noise.sigma] - standard deviation of pixels in generated noise.
+ * @param {Object} [options.text] - describes a new text image to be created.
+ * @param {string} [options.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+ * @param {string} [options.text.font] - font name to render with.
+ * @param {string} [options.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
+ * @param {number} [options.text.width=0] - integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
+ * @param {number} [options.text.height=0] - integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
+ * @param {string} [options.text.align='left'] - text alignment (`'left'`, `'centre'`, `'center'`, `'right'`).
+ * @param {boolean} [options.text.justify=false] - set this to true to apply justification to the text.
+ * @param {number} [options.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
+ * @param {boolean} [options.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`.
+ * @param {number} [options.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -192,6 +224,7 @@ const Sharp = function (input, options) {
     sharpenY3: 20,
     threshold: 0,
     thresholdGrayscale: true,
+    trimBackground: [],
     trimThreshold: 0,
     gamma: 0,
     gammaOut: 0,
@@ -251,9 +284,12 @@ const Sharp = function (input, options) {
     webpNearLossless: false,
     webpSmartSubsample: false,
     webpEffort: 4,
+    webpMinSize: false,
+    webpMixed: false,
     gifBitdepth: 8,
     gifEffort: 7,
     gifDither: 1,
+    gifReoptimise: false,
     tiffQuality: 80,
     tiffCompression: 'jpeg',
     tiffPredictor: 'horizontal',
@@ -282,9 +318,10 @@ const Sharp = function (input, options) {
     tileBackground: [255, 255, 255, 255],
     tileCentre: false,
     tileId: 'https://example.com/iiif',
+    tileBasename: '',
     timeoutSeconds: 0,
-    linearA: 1,
-    linearB: 0,
+    linearA: [],
+    linearB: [],
     // Function to notify of libvips warnings
     debuglog: warning => {
       this.emit('warning', warning);
@@ -346,7 +383,7 @@ Object.setPrototypeOf(Sharp, stream.Duplex);
  *     .toFile("optimized-500.webp")
  * );
  *
- * // https://github.com/sindresorhus/got#gotstreamurl-options
+ * // https://github.com/sindresorhus/got/blob/main/documentation/3-streams.md
  * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
  *
  * Promise.all(promises)

package/lib/input.js

@@ -4,6 +4,18 @@ const color = require('color');
 const is = require('./is');
 const sharp = require('./sharp');
 
+/**
+ * Justication alignment
+ * @member
+ * @private
+ */
+const align = {
+  left: 'low',
+  center: 'centre',
+  centre: 'centre',
+  right: 'high'
+};
+
 /**
  * Extract input options, if any, from an object.
  * @private
@@ -245,6 +257,81 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw new Error('Expected valid width, height and channels to create a new input image');
       }
     }
+    // Create a new image with text
+    if (is.defined(inputOptions.text)) {
+      if (is.object(inputOptions.text) && is.string(inputOptions.text.text)) {
+        inputDescriptor.textValue = inputOptions.text.text;
+        if (is.defined(inputOptions.text.height) && is.defined(inputOptions.text.dpi)) {
+          throw new Error('Expected only one of dpi or height');
+        }
+        if (is.defined(inputOptions.text.font)) {
+          if (is.string(inputOptions.text.font)) {
+            inputDescriptor.textFont = inputOptions.text.font;
+          } else {
+            throw is.invalidParameterError('text.font', 'string', inputOptions.text.font);
+          }
+        }
+        if (is.defined(inputOptions.text.fontfile)) {
+          if (is.string(inputOptions.text.fontfile)) {
+            inputDescriptor.textFontfile = inputOptions.text.fontfile;
+          } else {
+            throw is.invalidParameterError('text.fontfile', 'string', inputOptions.text.fontfile);
+          }
+        }
+        if (is.defined(inputOptions.text.width)) {
+          if (is.number(inputOptions.text.width)) {
+            inputDescriptor.textWidth = inputOptions.text.width;
+          } else {
+            throw is.invalidParameterError('text.textWidth', 'number', inputOptions.text.width);
+          }
+        }
+        if (is.defined(inputOptions.text.height)) {
+          if (is.number(inputOptions.text.height)) {
+            inputDescriptor.textHeight = inputOptions.text.height;
+          } else {
+            throw is.invalidParameterError('text.height', 'number', inputOptions.text.height);
+          }
+        }
+        if (is.defined(inputOptions.text.align)) {
+          if (is.string(inputOptions.text.align) && is.string(this.constructor.align[inputOptions.text.align])) {
+            inputDescriptor.textAlign = this.constructor.align[inputOptions.text.align];
+          } else {
+            throw is.invalidParameterError('text.align', 'valid alignment', inputOptions.text.align);
+          }
+        }
+        if (is.defined(inputOptions.text.justify)) {
+          if (is.bool(inputOptions.text.justify)) {
+            inputDescriptor.textJustify = inputOptions.text.justify;
+          } else {
+            throw is.invalidParameterError('text.justify', 'boolean', inputOptions.text.justify);
+          }
+        }
+        if (is.defined(inputOptions.text.dpi)) {
+          if (is.number(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 100000)) {
+            inputDescriptor.textDpi = inputOptions.text.dpi;
+          } else {
+            throw is.invalidParameterError('text.dpi', 'number between 1 and 100000', inputOptions.text.dpi);
+          }
+        }
+        if (is.defined(inputOptions.text.rgba)) {
+          if (is.bool(inputOptions.text.rgba)) {
+            inputDescriptor.textRgba = inputOptions.text.rgba;
+          } else {
+            throw is.invalidParameterError('text.rgba', 'bool', inputOptions.text.rgba);
+          }
+        }
+        if (is.defined(inputOptions.text.spacing)) {
+          if (is.number(inputOptions.text.spacing)) {
+            inputDescriptor.textSpacing = inputOptions.text.spacing;
+          } else {
+            throw is.invalidParameterError('text.spacing', 'number', inputOptions.text.spacing);
+          }
+        }
+        delete inputDescriptor.buffer;
+      } else {
+        throw new Error('Expected a valid string to create an image with text.');
+      }
+    }
   } else if (is.defined(inputOptions)) {
     throw new Error('Invalid input options ' + inputOptions);
   }
@@ -303,6 +390,9 @@ function _isStreamInput () {
  * This is taken from the header of the input image.
  * It does not include operations, such as resize, to be applied to the output image.
  *
+ * Dimensions in the response will respect the `page` and `pages` properties of the
+ * {@link /api-constructor#parameters|constructor parameters}.
+ *
  * A `Promise` is returned when `callback` is not provided.
  *
  * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
@@ -504,4 +594,6 @@ module.exports = function (Sharp) {
     metadata,
     stats
   });
+  // Class attributes
+  Sharp.align = align;
 };

package/lib/operation.js

@@ -18,8 +18,11 @@ const is = require('./is');
  *
  * The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
  *
- * Method order is important when both rotating and extracting regions,
- * for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
+ * Only one rotation can occur per pipeline.
+ * Previous calls to `rotate` in the same pipeline will be ignored.
+ *
+ * Method order is important when rotating, resizing and/or extracting regions,
+ * for example `.rotate(x).extract(y)` will produce a different result to `.extract(y).rotate(x)`.
  *
  * @example
  * const pipeline = sharp()
@@ -32,6 +35,16 @@ const is = require('./is');
  *   });
  * readableStream.pipe(pipeline);
  *
+ * @example
+ * const rotateThenResize = await sharp(input)
+ *   .rotate(90)
+ *   .resize({ width: 16, height: 8, fit: 'fill' })
+ *   .toBuffer();
+ * const resizeThenRotate = await sharp(input)
+ *   .resize({ width: 16, height: 8, fit: 'fill' })
+ *   .rotate(90)
+ *   .toBuffer();
+ *
  * @param {number} [angle=auto] angle of rotation.
  * @param {Object} [options] - if present, is an Object with optional attributes.
  * @param {string|Object} [options.background="#000000"] parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
@@ -39,6 +52,9 @@ const is = require('./is');
  * @throws {Error} Invalid parameters
  */
 function rotate (angle, options) {
+  if (this.options.useExifOrientation || this.options.angle || this.options.rotationAngle) {
+    this.options.debuglog('ignoring previous rotate options');
+  }
   if (!is.defined(angle)) {
     this.options.useExifOrientation = true;
   } else if (is.integer(angle) && !(angle % 90)) {
@@ -61,7 +77,7 @@ function rotate (angle, options) {
 }
 
 /**
- * Flip the image about the vertical Y axis. This always occurs after rotation, if any.
+ * Flip the image about the vertical Y axis. This always occurs before rotation, if any.
  * The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
  *
  * @example
@@ -76,7 +92,7 @@ function flip (flip) {
 }
 
 /**
- * Flop the image about the horizontal X axis. This always occurs after rotation, if any.
+ * Flop the image about the horizontal X axis. This always occurs before rotation, if any.
  * The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
  *
  * @example
@@ -205,7 +221,7 @@ function affine (matrix, options) {
  * const data = await sharp(input)
  *   .sharpen({
  *     sigma: 2,
- *     m1: 0
+ *     m1: 0,
  *     m2: 3,
  *     x1: 3,
  *     y2: 15,
@@ -628,26 +644,55 @@ function boolean (operand, operator, options) {
 }
 
 /**
- * Apply the linear formula a * input + b to the image (levels adjustment)
- * @param {number} [a=1.0] multiplier
- * @param {number} [b=0.0] offset
+ * Apply the linear formula `a` * input + `b` to the image to adjust image levels.
+ *
+ * When a single number is provided, it will be used for all image channels.
+ * When an array of numbers is provided, the array length must match the number of channels.
+ *
+ * @example
+ * await sharp(input)
+ *   .linear(0.5, 2)
+ *   .toBuffer();
+ *
+ * @example
+ * await sharp(rgbInput)
+ *   .linear(
+ *     [0.25, 0.5, 0.75],
+ *     [150, 100, 50]
+ *   )
+ *   .toBuffer();
+ *
+ * @param {(number|number[])} [a=[]] multiplier
+ * @param {(number|number[])} [b=[]] offset
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function linear (a, b) {
+  if (!is.defined(a) && is.number(b)) {
+    a = 1.0;
+  } else if (is.number(a) && !is.defined(b)) {
+    b = 0.0;
+  }
   if (!is.defined(a)) {
-    this.options.linearA = 1.0;
+    this.options.linearA = [];
   } else if (is.number(a)) {
+    this.options.linearA = [a];
+  } else if (Array.isArray(a) && a.length && a.every(is.number)) {
     this.options.linearA = a;
   } else {
-    throw is.invalidParameterError('a', 'numeric', a);
+    throw is.invalidParameterError('a', 'number or array of numbers', a);
   }
   if (!is.defined(b)) {
-    this.options.linearB = 0.0;
+    this.options.linearB = [];
   } else if (is.number(b)) {
+    this.options.linearB = [b];
+  } else if (Array.isArray(b) && b.length && b.every(is.number)) {
     this.options.linearB = b;
   } else {
-    throw is.invalidParameterError('b', 'numeric', b);
+    throw is.invalidParameterError('b', 'number or array of numbers', b);
+  }
+  if (this.options.linearA.length !== this.options.linearB.length) {
+    throw new Error('Expected a and b to be arrays of the same length');
   }
   return this;
 }

package/lib/output.js

@@ -10,6 +10,9 @@ const formats = new Map([
   ['avif', 'avif'],
   ['jpeg', 'jpeg'],
   ['jpg', 'jpeg'],
+  ['jpe', 'jpeg'],
+  ['tile', 'tile'],
+  ['dz', 'tile'],
   ['png', 'png'],
   ['raw', 'raw'],
   ['tiff', 'tiff'],
@@ -55,6 +58,7 @@ const bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math
  * `info` contains the output image `format`, `size` (bytes), `width`, `height`,
  * `channels` and `premultiplied` (indicating if premultiplication was used).
  * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+ * May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
  * @returns {Promise<Object>} - when no callback is provided
  * @throws {Error} Invalid parameters
  */
@@ -95,6 +99,7 @@ function toFile (fileOut, callback) {
  * - `info` contains the output image `format`, `size` (bytes), `width`, `height`,
  * `channels` and `premultiplied` (indicating if premultiplication was used).
  * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
+ * May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
  *
  * A `Promise` is returned when `callback` is not provided.
  *
@@ -402,6 +407,14 @@ function png (options) {
     if (is.defined(options.adaptiveFiltering)) {
       this._setBooleanOption('pngAdaptiveFiltering', options.adaptiveFiltering);
     }
+    const colours = options.colours || options.colors;
+    if (is.defined(colours)) {
+      if (is.integer(colours) && is.inRange(colours, 2, 256)) {
+        this.options.pngBitdepth = bitdepthFromColourCount(colours);
+      } else {
+        throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
+      }
+    }
     if (is.defined(options.palette)) {
       this._setBooleanOption('pngPalette', options.palette);
     } else if ([options.quality, options.effort, options.colours, options.colors, options.dither].some(is.defined)) {
@@ -422,14 +435,6 @@ function png (options) {
           throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
         }
       }
-      const colours = options.colours || options.colors;
-      if (is.defined(colours)) {
-        if (is.integer(colours) && is.inRange(colours, 2, 256)) {
-          this.options.pngBitdepth = bitdepthFromColourCount(colours);
-        } else {
-          throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
-        }
-      }
       if (is.defined(options.dither)) {
         if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
           this.options.pngDither = options.dither;
@@ -466,6 +471,8 @@ function png (options) {
  * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 6 (slowest)
  * @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.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.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -495,14 +502,19 @@ function webp (options) {
     if (is.defined(options.smartSubsample)) {
       this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
     }
-    const effort = is.defined(options.effort) ? options.effort : options.reductionEffort;
-    if (is.defined(effort)) {
-      if (is.integer(effort) && is.inRange(effort, 0, 6)) {
-        this.options.webpEffort = effort;
+    if (is.defined(options.effort)) {
+      if (is.integer(options.effort) && is.inRange(options.effort, 0, 6)) {
+        this.options.webpEffort = options.effort;
       } else {
-        throw is.invalidParameterError('effort', 'integer between 0 and 6', effort);
+        throw is.invalidParameterError('effort', 'integer between 0 and 6', options.effort);
       }
     }
+    if (is.defined(options.minSize)) {
+      this._setBooleanOption('webpMinSize', options.minSize);
+    }
+    if (is.defined(options.mixed)) {
+      this._setBooleanOption('webpMixed', options.mixed);
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('webp', options);
@@ -513,6 +525,8 @@ function webp (options) {
  *
  * The first entry in the palette is reserved for transparency.
  *
+ * The palette of the input image will be re-used if possible.
+ *
  * @since 0.30.0
  *
  * @example
@@ -534,6 +548,8 @@ function webp (options) {
  *   .toBuffer();
  *
  * @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`
  * @param {number} [options.colours=256] - maximum number of palette entries, including transparency, between 2 and 256
  * @param {number} [options.colors=256] - alternative spelling of `options.colours`
  * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest)
@@ -546,6 +562,11 @@ function webp (options) {
  */
 function gif (options) {
   if (is.object(options)) {
+    if (is.defined(options.reoptimise)) {
+      this._setBooleanOption('gifReoptimise', options.reoptimise);
+    } else if (is.defined(options.reoptimize)) {
+      this._setBooleanOption('gifReoptimise', options.reoptimize);
+    }
     const colours = options.colours || options.colors;
     if (is.defined(colours)) {
       if (is.integer(colours) && is.inRange(colours, 2, 256)) {
@@ -702,7 +723,7 @@ function trySetAnimationOptions (source, target) {
  * @param {Object} [options] - output options
  * @param {number} [options.quality=80] - quality, integer 1-100
  * @param {boolean} [options.force=true] - force TIFF output, otherwise attempt to use input format
- * @param {string} [options.compression='jpeg'] - compression options: lzw, deflate, jpeg, ccittfax4
+ * @param {string} [options.compression='jpeg'] - compression options: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k
  * @param {string} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
  * @param {boolean} [options.pyramid=false] - write an image pyramid
  * @param {boolean} [options.tile=false] - write a tiled tiff
@@ -770,10 +791,10 @@ function tiff (options) {
     }
     // compression
     if (is.defined(options.compression)) {
-      if (is.string(options.compression) && is.inArray(options.compression, ['lzw', 'deflate', 'jpeg', 'ccittfax4', 'none'])) {
+      if (is.string(options.compression) && is.inArray(options.compression, ['none', 'jpeg', 'deflate', 'packbits', 'ccittfax4', 'lzw', 'webp', 'zstd', 'jp2k'])) {
         this.options.tiffCompression = options.compression;
       } else {
-        throw is.invalidParameterError('compression', 'one of: lzw, deflate, jpeg, ccittfax4, none', options.compression);
+        throw is.invalidParameterError('compression', 'one of: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k', options.compression);
       }
     }
     // predictor
@@ -804,6 +825,16 @@ function tiff (options) {
  *
  * AVIF image sequences are not supported.
  *
+ * @example
+ * const data = await sharp(input)
+ *   .avif({ effort: 2 })
+ *   .toBuffer();
+ *
+ * @example
+ * const data = await sharp(input)
+ *   .avif({ lossless: true })
+ *   .toBuffer();
+ *
  * @since 0.27.0
  *
  * @param {Object} [options] - output options
@@ -821,9 +852,14 @@ function avif (options) {
 /**
  * Use these HEIF options for output image.
  *
- * Support for patent-encumbered HEIC images requires the use of a
+ * Support for patent-encumbered HEIC images using `hevc` compression requires the use of a
  * globally-installed libvips compiled with support for libheif, libde265 and x265.
  *
+ * @example
+ * const data = await sharp(input)
+ *   .heif({ compression: 'hevc' })
+ *   .toBuffer();
+ *
  * @since 0.23.0
  *
  * @param {Object} [options] - output options
@@ -864,12 +900,6 @@ function heif (options) {
       } else {
         throw is.invalidParameterError('effort', 'integer between 0 and 9', options.effort);
       }
-    } else if (is.defined(options.speed)) {
-      if (is.integer(options.speed) && is.inRange(options.speed, 0, 9)) {
-        this.options.heifEffort = 9 - options.speed;
-      } else {
-        throw is.invalidParameterError('speed', 'integer between 0 and 9', options.speed);
-      }
     }
     if (is.defined(options.chromaSubsampling)) {
       if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
@@ -923,9 +953,12 @@ function raw (options) {
 
 /**
  * Use tile-based deep zoom (image pyramid) output.
+ *
  * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
  * Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
  *
+ * The container will be set to `zip` when the output is a Buffer or Stream, otherwise it will default to `fs`.
+ *
  * @example
  *  sharp('input.tiff')
  *   .png()
@@ -937,6 +970,17 @@ function raw (options) {
  *     // output_files contains 512x512 tiles grouped by zoom level
  *   });
  *
+ * @example
+ * const zipFileWithTiles = await sharp(input)
+ *   .tile({ basename: "tiles" })
+ *   .toBuffer();
+ *
+ * @example
+ * const iiififier = sharp().tile({ layout: "iiif" });
+ * readableStream
+ *   .pipe(iiififier)
+ *   .pipe(writeableStream);
+ *
  * @param {Object} [options]
  * @param {number} [options.size=256] tile size in pixels, a value between 1 and 8192.
  * @param {number} [options.overlap=0] tile overlap in pixels, a value between 0 and 8192.
@@ -949,6 +993,7 @@ function raw (options) {
  * @param {boolean} [options.centre=false] centre image in tile.
  * @param {boolean} [options.center=false] alternative spelling of centre.
  * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json`
+ * @param {string} [options.basename] the name of the directory within the zip file when container is `zip`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -1030,6 +1075,14 @@ function tile (options) {
         throw is.invalidParameterError('id', 'string', options.id);
       }
     }
+    // Basename for zip container
+    if (is.defined(options.basename)) {
+      if (is.string(options.basename)) {
+        this.options.tileBasename = options.basename;
+      } else {
+        throw is.invalidParameterError('basename', 'string', options.basename);
+      }
+    }
   }
   // Format
   if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {
@@ -1047,6 +1100,17 @@ function tile (options) {
  * The clock starts when libvips opens an input image for processing.
  * Time spent waiting for a libuv thread to become available is not included.
  *
+ * @example
+ * // Ensure processing takes no longer than 3 seconds
+ * try {
+ *   const data = await sharp(input)
+ *     .blur(1000)
+ *     .timeout({ seconds: 3 })
+ *     .toBuffer();
+ * } catch (err) {
+ *   if (err.message.includes('timeout')) { ... }
+ * }
+ *
  * @since 0.29.2
  *
  * @param {Object} options