sharp 0.29.0 → 0.30.0

package/lib/output.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const path = require('path');
 const is = require('./is');
 const sharp = require('./sharp');
 
@@ -12,22 +13,31 @@ const formats = new Map([
   ['png', 'png'],
   ['raw', 'raw'],
   ['tiff', 'tiff'],
+  ['tif', 'tiff'],
   ['webp', 'webp'],
-  ['gif', 'gif']
+  ['gif', 'gif'],
+  ['jp2', 'jp2'],
+  ['jpx', 'jp2'],
+  ['j2k', 'jp2'],
+  ['j2c', 'jp2']
 ]);
 
-const errMagickSave = new Error('GIF output requires libvips with support for ImageMagick');
+const errJp2Save = new Error('JP2 output requires libvips with support for OpenJPEG');
+
+const bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));
 
 /**
  * Write output image data to a file.
  *
  * If an explicit output format is not selected, it will be inferred from the extension,
- * with JPEG, PNG, WebP, AVIF, TIFF, DZI, and libvips' V format supported.
+ * with JPEG, PNG, WebP, AVIF, TIFF, GIF, DZI, and libvips' V format supported.
  * Note that raw pixel data is only supported for buffer output.
  *
  * By default all metadata will be removed, which includes EXIF-based orientation.
  * See {@link withMetadata} for control over this.
  *
+ * The caller is responsible for ensuring directory structures and permissions exist.
+ *
  * A `Promise` is returned when `callback` is not provided.
  *
  * @example
@@ -52,10 +62,8 @@ function toFile (fileOut, callback) {
   let err;
   if (!is.string(fileOut)) {
     err = new Error('Missing output file path');
-  } else if (this.options.input.file === fileOut) {
+  } 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 (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
-    err = errMagickSave;
   }
   if (err) {
     if (is.fn(callback)) {
@@ -72,9 +80,9 @@ function toFile (fileOut, callback) {
 
 /**
  * Write output to a Buffer.
- * JPEG, PNG, WebP, AVIF, TIFF and raw pixel data output are supported.
+ * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
  *
- * If no explicit format is set, the output format will match the input image, except GIF and SVG input which become PNG output.
+ * 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 withMetadata} for control over this.
@@ -160,7 +168,7 @@ function toBuffer (options, callback) {
  *   })
  *   .toBuffer();
  *
- *  * @example
+ * @example
  * // Set output metadata to 96 DPI
  * const data = await sharp(input)
  *   .withMetadata({ density: 96 })
@@ -365,6 +373,7 @@ function jpeg (options) {
  * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
  * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support
  * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
+ * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true`
  * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`
  * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`
  * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`
@@ -389,7 +398,7 @@ function png (options) {
     }
     if (is.defined(options.palette)) {
       this._setBooleanOption('pngPalette', options.palette);
-    } else if (is.defined(options.quality) || is.defined(options.colours || options.colors) || is.defined(options.dither)) {
+    } else if ([options.quality, options.effort, options.colours, options.colors, options.dither].some(is.defined)) {
       this._setBooleanOption('pngPalette', true);
     }
     if (this.options.pngPalette) {
@@ -400,10 +409,17 @@ function png (options) {
           throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
         }
       }
+      if (is.defined(options.effort)) {
+        if (is.integer(options.effort) && is.inRange(options.effort, 1, 10)) {
+          this.options.pngEffort = options.effort;
+        } else {
+          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.pngColours = colours;
+          this.options.pngBitdepth = bitdepthFromColourCount(colours);
         } else {
           throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
         }
@@ -432,7 +448,7 @@ function png (options) {
  * @example
  * // Optimise the file size of an animated WebP
  * const outputWebp = await sharp(inputWebp, { animated: true })
- *   .webp({ reductionEffort: 6 })
+ *   .webp({ effort: 6 })
  *   .toBuffer();
  *
  * @param {Object} [options] - output options
@@ -441,93 +457,205 @@ function png (options) {
  * @param {boolean} [options.lossless=false] - use lossless compression mode
  * @param {boolean} [options.nearLossless=false] - use near_lossless compression mode
  * @param {boolean} [options.smartSubsample=false] - use high quality chroma subsampling
- * @param {number} [options.reductionEffort=4] - level of CPU effort to reduce file size, integer 0-6
- * @param {number} [options.pageHeight] - page height for animated output
+ * @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[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
 function webp (options) {
-  if (is.object(options) && is.defined(options.quality)) {
-    if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
-      this.options.webpQuality = options.quality;
-    } else {
-      throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.webpQuality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
     }
-  }
-  if (is.object(options) && is.defined(options.alphaQuality)) {
-    if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
-      this.options.webpAlphaQuality = options.alphaQuality;
-    } else {
-      throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
+    if (is.defined(options.alphaQuality)) {
+      if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
+        this.options.webpAlphaQuality = options.alphaQuality;
+      } else {
+        throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
+      }
     }
-  }
-  if (is.object(options) && is.defined(options.lossless)) {
-    this._setBooleanOption('webpLossless', options.lossless);
-  }
-  if (is.object(options) && is.defined(options.nearLossless)) {
-    this._setBooleanOption('webpNearLossless', options.nearLossless);
-  }
-  if (is.object(options) && is.defined(options.smartSubsample)) {
-    this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
-  }
-  if (is.object(options) && is.defined(options.reductionEffort)) {
-    if (is.integer(options.reductionEffort) && is.inRange(options.reductionEffort, 0, 6)) {
-      this.options.webpReductionEffort = options.reductionEffort;
-    } else {
-      throw is.invalidParameterError('reductionEffort', 'integer between 0 and 6', options.reductionEffort);
+    if (is.defined(options.lossless)) {
+      this._setBooleanOption('webpLossless', options.lossless);
+    }
+    if (is.defined(options.nearLossless)) {
+      this._setBooleanOption('webpNearLossless', options.nearLossless);
+    }
+    if (is.defined(options.smartSubsample)) {
+      this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
+    }
+    const effort = options.effort || options.reductionEffort;
+    if (is.defined(effort)) {
+      if (is.integer(effort) && is.inRange(effort, 0, 6)) {
+        this.options.webpEffort = effort;
+      } else {
+        throw is.invalidParameterError('effort', 'integer between 0 and 6', effort);
+      }
     }
   }
-
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('webp', options);
 }
 
 /**
- * Use these GIF options for output image.
+ * Use these GIF options for the output image.
  *
- * Requires libvips compiled with support for ImageMagick or GraphicsMagick.
- * The prebuilt binaries do not include this - see
- * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ * The first entry in the palette is reserved for transparency.
+ *
+ * @since 0.30.0
+ *
+ * @example
+ * // Convert PNG to GIF
+ * await sharp(pngBuffer)
+ *   .gif()
+ *   .toBuffer());
+ *
+ * @example
+ * // Convert animated WebP to animated GIF
+ * await sharp('animated.webp', { animated: true })
+ *   .toFile('animated.gif');
+ *
+ * @example
+ * // Create a 128x128, cropped, non-dithered, animated thumbnail of an animated GIF
+ * const out = await sharp('in.gif', { animated: true })
+ *   .resize({ width: 128, height: 128 })
+ *   .gif({ dither: 0 })
+ *   .toBuffer();
  *
  * @param {Object} [options] - output options
- * @param {number} [options.pageHeight] - page height for animated output
+ * @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)
+ * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most)
  * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
- * @param {number[]} [options.delay] - list of delays between animation frames (in milliseconds)
+ * @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
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
-/* istanbul ignore next */
 function gif (options) {
-  if (!this.constructor.format.magick.output.buffer) {
-    throw errMagickSave;
+  if (is.object(options)) {
+    const colours = options.colours || options.colors;
+    if (is.defined(colours)) {
+      if (is.integer(colours) && is.inRange(colours, 2, 256)) {
+        this.options.gifBitdepth = bitdepthFromColourCount(colours);
+      } else {
+        throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
+      }
+    }
+    if (is.defined(options.effort)) {
+      if (is.number(options.effort) && is.inRange(options.effort, 1, 10)) {
+        this.options.gifEffort = options.effort;
+      } else {
+        throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
+      }
+    }
+    if (is.defined(options.dither)) {
+      if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
+        this.options.gifDither = options.dither;
+      } else {
+        throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
+      }
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('gif', options);
 }
 
+/**
+ * Use these JP2 options for output image.
+ *
+ * Requires libvips compiled with support for OpenJPEG.
+ * The prebuilt binaries do not include this - see
+ * {@link https://sharp.pixelplumbing.com/install#custom-libvips installing a custom libvips}.
+ *
+ * @example
+ * // Convert any input to lossless JP2 output
+ * const data = await sharp(input)
+ *   .jp2({ lossless: true })
+ *   .toBuffer();
+ *
+ * @example
+ * // Convert any input to very high quality JP2 output
+ * const data = await sharp(input)
+ *   .jp2({
+ *     quality: 100,
+ *     chromaSubsampling: '4:4:4'
+ *   })
+ *   .toBuffer();
+ *
+ * @since 0.29.1
+ *
+ * @param {Object} [options] - output options
+ * @param {number} [options.quality=80] - quality, integer 1-100
+ * @param {boolean} [options.lossless=false] - use lossless compression mode
+ * @param {number} [options.tileWidth=512] - horizontal tile size
+ * @param {number} [options.tileHeight=512] - vertical tile size
+ * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
+ * @returns {Sharp}
+ * @throws {Error} Invalid options
+ */
+/* istanbul ignore next */
+function jp2 (options) {
+  if (!this.constructor.format.jp2k.output.buffer) {
+    throw errJp2Save;
+  }
+  if (is.object(options)) {
+    if (is.defined(options.quality)) {
+      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
+        this.options.jp2Quality = options.quality;
+      } else {
+        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
+      }
+    }
+    if (is.defined(options.lossless)) {
+      if (is.bool(options.lossless)) {
+        this.options.jp2Lossless = options.lossless;
+      } else {
+        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
+      }
+    }
+    if (is.defined(options.tileWidth)) {
+      if (is.integer(options.tileWidth) && is.inRange(options.tileWidth, 1, 32768)) {
+        this.options.jp2TileWidth = options.tileWidth;
+      } else {
+        throw is.invalidParameterError('tileWidth', 'integer between 1 and 32768', options.tileWidth);
+      }
+    }
+    if (is.defined(options.tileHeight)) {
+      if (is.integer(options.tileHeight) && is.inRange(options.tileHeight, 1, 32768)) {
+        this.options.jp2TileHeight = options.tileHeight;
+      } else {
+        throw is.invalidParameterError('tileHeight', 'integer between 1 and 32768', options.tileHeight);
+      }
+    }
+    if (is.defined(options.chromaSubsampling)) {
+      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
+        this.options.heifChromaSubsampling = options.chromaSubsampling;
+      } else {
+        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
+      }
+    }
+  }
+  return this._updateFormatOut('jp2', options);
+}
+
 /**
  * Set animation options if available.
  * @private
  *
  * @param {Object} [source] - output options
- * @param {number} [source.pageHeight] - page height for animated output
  * @param {number} [source.loop=0] - number of animation iterations, use 0 for infinite animation
  * @param {number[]} [source.delay] - list of delays between animation frames (in milliseconds)
  * @param {Object} [target] - target object for valid options
  * @throws {Error} Invalid options
  */
 function trySetAnimationOptions (source, target) {
-  if (is.object(source) && is.defined(source.pageHeight)) {
-    if (is.integer(source.pageHeight) && source.pageHeight > 0) {
-      target.pageHeight = source.pageHeight;
-    } else {
-      throw is.invalidParameterError('pageHeight', 'integer larger than 0', source.pageHeight);
-    }
-  }
   if (is.object(source) && is.defined(source.loop)) {
     if (is.integer(source.loop) && is.inRange(source.loop, 0, 65535)) {
       target.loop = source.loop;
@@ -536,13 +664,16 @@ function trySetAnimationOptions (source, target) {
     }
   }
   if (is.object(source) && is.defined(source.delay)) {
-    if (
+    // We allow singular values as well
+    if (is.integer(source.delay) && is.inRange(source.delay, 0, 65535)) {
+      target.delay = [source.delay];
+    } else if (
       Array.isArray(source.delay) &&
       source.delay.every(is.integer) &&
       source.delay.every(v => is.inRange(v, 0, 65535))) {
       target.delay = source.delay;
     } else {
-      throw is.invalidParameterError('delay', 'array of integers between 0 and 65535', source.delay);
+      throw is.invalidParameterError('delay', 'integer or an array of integers between 0 and 65535', source.delay);
     }
   }
 }
@@ -550,6 +681,8 @@ function trySetAnimationOptions (source, target) {
 /**
  * Use these TIFF options for output image.
  *
+ * The `density` can be set in pixels/inch via {@link withMetadata} instead of providing `xres` and `yres` in pixels/mm.
+ *
  * @example
  * // Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
  * sharp('input.svg')
@@ -571,6 +704,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.tileHeight=256] - vertical tile size
  * @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
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -644,6 +778,14 @@ function tiff (options) {
         throw is.invalidParameterError('predictor', 'one of: none, horizontal, float', options.predictor);
       }
     }
+    // resolutionUnit
+    if (is.defined(options.resolutionUnit)) {
+      if (is.string(options.resolutionUnit) && is.inArray(options.resolutionUnit, ['inch', 'cm'])) {
+        this.options.tiffResolutionUnit = options.resolutionUnit;
+      } else {
+        throw is.invalidParameterError('resolutionUnit', 'one of: inch, cm', options.resolutionUnit);
+      }
+    }
   }
   return this._updateFormatOut('tiff', options);
 }
@@ -654,12 +796,14 @@ function tiff (options) {
  * Whilst it is possible to create AVIF images smaller than 16x16 pixels,
  * most web browsers do not display these properly.
  *
+ * AVIF image sequences are not supported.
+ *
  * @since 0.27.0
  *
  * @param {Object} [options] - output options
  * @param {number} [options.quality=50] - quality, integer 1-100
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @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
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -680,7 +824,7 @@ function avif (options) {
  * @param {number} [options.quality=50] - quality, integer 1-100
  * @param {string} [options.compression='av1'] - compression format: av1, hevc
  * @param {boolean} [options.lossless=false] - use lossless compression
- * @param {number} [options.speed=5] - CPU effort vs file size, 0 (slowest/smallest) to 8 (fastest/largest)
+ * @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
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -708,11 +852,17 @@ function heif (options) {
         throw is.invalidParameterError('compression', 'one of: av1, hevc', options.compression);
       }
     }
-    if (is.defined(options.speed)) {
-      if (is.integer(options.speed) && is.inRange(options.speed, 0, 8)) {
-        this.options.heifSpeed = options.speed;
+    if (is.defined(options.effort)) {
+      if (is.integer(options.effort) && is.inRange(options.effort, 0, 9)) {
+        this.options.heifEffort = options.effort;
+      } 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 8', options.speed);
+        throw is.invalidParameterError('speed', 'integer between 0 and 9', options.speed);
       }
     }
     if (is.defined(options.chromaSubsampling)) {
@@ -770,8 +920,6 @@ function raw (options) {
  * 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.
  *
- * Warning: multiple sharp instances concurrently producing tile output can expose a possible race condition in some versions of libgsf.
- *
  * @example
  *  sharp('input.tiff')
  *   .png()
@@ -791,10 +939,10 @@ function raw (options) {
  * @param {string} [options.depth] how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
  * @param {number} [options.skipBlanks=-1] threshold to skip tile generation, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images
  * @param {string} [options.container='fs'] tile container, with value `fs` (filesystem) or `zip` (compressed file).
- * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`.
+ * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `iiif3`, `zoomify` or `google`.
  * @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`, sets the `@id` attribute of `info.json`
+ * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json`
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -829,10 +977,10 @@ function tile (options) {
     }
     // Layout
     if (is.defined(options.layout)) {
-      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'zoomify'])) {
+      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'iiif3', 'zoomify'])) {
         this.options.tileLayout = options.layout;
       } else {
-        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, zoomify', options.layout);
+        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, iiif3, zoomify', options.layout);
       }
     }
     // Angle of rotation,
@@ -886,6 +1034,31 @@ function tile (options) {
   return this._updateFormatOut('dz');
 }
 
+/**
+ * Set a timeout for processing, in seconds.
+ * Use a value of zero to continue processing indefinitely, the default behaviour.
+ *
+ * The clock starts when libvips opens an input image for processing.
+ * Time spent waiting for a libuv thread to become available is not included.
+ *
+ * @since 0.29.2
+ *
+ * @param {Object} options
+ * @param {number} options.seconds - Number of seconds after which processing will be stopped
+ * @returns {Sharp}
+ */
+function timeout (options) {
+  if (!is.plainObject(options)) {
+    throw is.invalidParameterError('options', 'object', options);
+  }
+  if (is.integer(options.seconds) && is.inRange(options.seconds, 0, 3600)) {
+    this.options.timeoutSeconds = options.seconds;
+  } else {
+    throw is.invalidParameterError('seconds', 'integer between 0 and 3600', options.seconds);
+  }
+  return this;
+}
+
 /**
  * Update the output format unless options.force is false,
  * in which case revert to input format.
@@ -962,6 +1135,7 @@ function _pipeline (callback) {
             this.push(data);
           }
           this.push(null);
+          this.emit('close');
         });
       });
       if (this.streamInFinished) {
@@ -977,6 +1151,7 @@ function _pipeline (callback) {
           this.push(data);
         }
         this.push(null);
+        this.emit('close');
       });
     }
     return this;
@@ -1031,6 +1206,7 @@ module.exports = function (Sharp) {
     withMetadata,
     toFormat,
     jpeg,
+    jp2,
     png,
     webp,
     tiff,
@@ -1039,6 +1215,7 @@ module.exports = function (Sharp) {
     gif,
     raw,
     tile,
+    timeout,
     // Private
     _updateFormatOut,
     _setBooleanOption,

package/lib/platform.js

@@ -8,7 +8,7 @@ module.exports = function () {
   const arch = env.npm_config_arch || process.arch;
   const platform = env.npm_config_platform || process.platform;
   /* istanbul ignore next */
-  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinux) ? detectLibc.family : '';
+  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinuxSync()) ? detectLibc.familySync() : '';
 
   const platformId = [`${platform}${libc}`];
 

package/lib/resize.js

@@ -183,6 +183,20 @@ function isRotationExpected (options) {
  *   });
  *
  * @example
+ * sharp(input)
+ *   .resize(200, 200, {
+ *     fit: sharp.fit.outside,
+ *     withoutReduction: true
+ *   })
+ *   .toFormat('jpeg')
+ *   .toBuffer()
+ *   .then(function(outputBuffer) {
+ *     // outputBuffer contains JPEG image data
+ *     // of at least 200 pixels wide and 200 pixels high while maintaining aspect ratio
+ *     // and no smaller than the input image
+ *   });
+ *
+ * @example
  * const scaleByHalf = await sharp(input)
  *   .metadata()
  *   .then(({ width }) => sharp(input)
@@ -200,6 +214,7 @@ function isRotationExpected (options) {
  * @param {String|Object} [options.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour when using a `fit` of `contain`, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @param {String} [options.kernel='lanczos3'] - the kernel to use for image reduction.
  * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option.
+ * @param {Boolean} [options.withoutReduction=false] - do not reduce if the width *or* height are already greater than the specified dimensions, equivalent to GraphicsMagick's `<` geometry option.
  * @param {Boolean} [options.fastShrinkOnLoad=true] - take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern on some images.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
@@ -276,6 +291,10 @@ function resize (width, height, options) {
     if (is.defined(options.withoutEnlargement)) {
       this._setBooleanOption('withoutEnlargement', options.withoutEnlargement);
     }
+    // Without reduction
+    if (is.defined(options.withoutReduction)) {
+      this._setBooleanOption('withoutReduction', options.withoutReduction);
+    }
     // Shrink on load
     if (is.defined(options.fastShrinkOnLoad)) {
       this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);

package/lib/sharp.js

@@ -11,14 +11,22 @@ try {
   if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
     help.push('- Update Homebrew: "brew update && brew upgrade vips"');
   } else {
+    const [platform, arch] = platformAndArch.split('-');
     help.push(
       '- Install with the --verbose flag and look for errors: "npm install --ignore-scripts=false --verbose sharp"',
-      `- Install for the current runtime: "npm install --platform=${process.platform} --arch=${process.arch} sharp"`
+      `- Install for the current ${platformAndArch} runtime: "npm install --platform=${platform} --arch=${arch} sharp"`
     );
   }
   help.push(
     '- Consult the installation documentation: https://sharp.pixelplumbing.com/install'
   );
-  console.error(help.join('\n'));
-  process.exit(1);
+  // Check loaded
+  if (process.platform === 'win32') {
+    const loadedModule = Object.keys(require.cache).find((i) => /[\\/]build[\\/]Release[\\/]sharp(.*)\.node$/.test(i));
+    if (loadedModule) {
+      const [, loadedPackage] = loadedModule.match(/node_modules[\\/]([^\\/]+)[\\/]/);
+      help.push(`- Ensure the version of sharp aligns with the ${loadedPackage} package: "npm ls sharp"`);
+    }
+  }
+  throw new Error(help.join('\n'));
 }