sharp 0.29.1 → 0.30.1

package/lib/output.js

@@ -13,6 +13,7 @@ const formats = new Map([
   ['png', 'png'],
   ['raw', 'raw'],
   ['tiff', 'tiff'],
+  ['tif', 'tiff'],
   ['webp', 'webp'],
   ['gif', 'gif'],
   ['jp2', 'jp2'],
@@ -21,14 +22,15 @@ const formats = new Map([
   ['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.
@@ -62,8 +64,6 @@ 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 (this.options.formatOut === 'input' && fileOut.toLowerCase().endsWith('.gif') && !this.constructor.format.magick.output.file) {
-    err = errMagickSave;
   }
   if (err) {
     if (is.fn(callback)) {
@@ -80,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.
@@ -139,6 +139,7 @@ function toBuffer (options, callback) {
   } else if (this.options.resolveWithObject) {
     this.options.resolveWithObject = false;
   }
+  this.options.fileOut = '';
   return this._pipeline(is.fn(options) ? options : callback);
 }
 
@@ -168,7 +169,7 @@ function toBuffer (options, callback) {
  *   })
  *   .toBuffer();
  *
- *  * @example
+ * @example
  * // Set output metadata to 96 DPI
  * const data = await sharp(input)
  *   .withMetadata({ density: 96 })
@@ -373,6 +374,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`
@@ -397,7 +399,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) {
@@ -408,10 +410,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.pngBitdepth = 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));
+          this.options.pngBitdepth = bitdepthFromColourCount(colours);
         } else {
           throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
         }
@@ -440,7 +449,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
@@ -449,69 +458,111 @@ 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);
@@ -600,20 +651,12 @@ function jp2 (options) {
  * @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;
@@ -622,13 +665,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);
     }
   }
 }
@@ -636,6 +682,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')
@@ -657,6 +705,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
@@ -730,6 +779,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);
 }
@@ -747,7 +804,7 @@ function tiff (options) {
  * @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 9 (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
@@ -768,7 +825,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 9 (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
@@ -796,9 +853,15 @@ function heif (options) {
         throw is.invalidParameterError('compression', 'one of: av1, hevc', options.compression);
       }
     }
-    if (is.defined(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.heifSpeed = options.speed;
+        this.options.heifEffort = 9 - options.speed;
       } else {
         throw is.invalidParameterError('speed', 'integer between 0 and 9', options.speed);
       }
@@ -858,8 +921,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()
@@ -879,10 +940,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
  */
@@ -917,10 +978,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,
@@ -974,6 +1035,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.
@@ -1050,6 +1136,7 @@ function _pipeline (callback) {
             this.push(data);
           }
           this.push(null);
+          this.emit('close');
         });
       });
       if (this.streamInFinished) {
@@ -1065,6 +1152,7 @@ function _pipeline (callback) {
           this.push(data);
         }
         this.push(null);
+        this.emit('close');
       });
     }
     return this;
@@ -1128,6 +1216,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'));
 }

package/lib/utility.js

@@ -1,9 +1,12 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const events = require('events');
 const detectLibc = require('detect-libc');
 
 const is = require('./is');
+const platformAndArch = require('./platform')();
 const sharp = require('./sharp');
 
 /**
@@ -27,11 +30,11 @@ const interpolators = {
   bilinear: 'bilinear',
   /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
   bicubic: 'bicubic',
-  /** [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+  /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
   locallyBoundedBicubic: 'lbb',
   /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
   nohalo: 'nohalo',
-  /** [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
   vertexSplitQuadraticBasisSpline: 'vsqbs'
 };
 
@@ -45,8 +48,23 @@ let versions = {
   vips: sharp.libvipsVersion()
 };
 try {
-  versions = require(`../vendor/${versions.vips}/versions.json`);
-} catch (err) {}
+  versions = require(`../vendor/${versions.vips}/${platformAndArch}/versions.json`);
+} catch (_err) { /* ignore */ }
+
+/**
+ * An Object containing the platform and architecture
+ * of the current and installed vendored binaries.
+ * @member
+ * @example
+ * console.log(sharp.vendor);
+ */
+const vendor = {
+  current: platformAndArch,
+  installed: []
+};
+try {
+  vendor.installed = fs.readdirSync(path.join(__dirname, `../vendor/${versions.vips}`));
+} catch (_err) { /* ignore */ }
 
 /**
  * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
@@ -110,7 +128,7 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* istanbul ignore next */
-if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 }
@@ -175,5 +193,6 @@ module.exports = function (Sharp) {
   Sharp.format = format;
   Sharp.interpolators = interpolators;
   Sharp.versions = versions;
+  Sharp.vendor = vendor;
   Sharp.queue = queue;
 };