sharp 0.32.5 → 0.33.0-alpha.10

package/README.md

@@ -2,10 +2,14 @@
 
 <img src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
 
-The typical use case for this high speed Node.js module
+The typical use case for this high speed Node-API module
 is to convert large images in common formats to
 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, Deno and Bun.
+
 Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings
 due to its use of [libvips](https://github.com/libvips/libvips).
@@ -16,7 +20,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 >= 14.15.0
+Most modern macOS, Windows and Linux systems
 do not require any additional install or runtime dependencies.
 
 ## Documentation

package/install/check.js

@@ -0,0 +1,36 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const { useGlobalLibvips, globalLibvipsVersion, log, spawnRebuild } = require('../lib/libvips');
+
+const buildFromSource = (msg) => {
+  log(msg);
+  log('Attempting to build from source via node-gyp');
+  try {
+    require('node-addon-api');
+    log('Found node-addon-api');
+  } catch (err) {
+    log('Please add node-addon-api to your dependencies');
+    return;
+  }
+  try {
+    const gyp = require('node-gyp');
+    log(`Found node-gyp version ${gyp().version}`);
+  } catch (err) {
+    log('Please add node-gyp to your dependencies');
+    return;
+  }
+  log('See https://sharp.pixelplumbing.com/install#building-from-source');
+  const status = spawnRebuild();
+  if (status !== 0) {
+    process.exit(status);
+  }
+};
+
+if (useGlobalLibvips()) {
+  buildFromSource(`Detected globally-installed libvips v${globalLibvipsVersion()}`);
+} else if (process.env.npm_config_build_from_source) {
+  buildFromSource('Detected --build-from-source flag');
+}

package/lib/constructor.js

@@ -3,11 +3,10 @@
 
 'use strict';
 
-const util = require('util');
-const stream = require('stream');
+const util = require('node:util');
+const stream = require('node:stream');
 const is = require('./is');
 
-require('./libvips').hasVendoredLibvips();
 require('./sharp');
 
 // Use NODE_DEBUG=sharp to enable libvips warnings
@@ -122,7 +121,7 @@ const debuglog = util.debuglog('sharp');
  *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
  *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
  * @param {Object} [options] - if present, is an Object with optional attributes.
- * @param {string} [options.failOn='warning'] - when to abort processing of invalid pixel data, one of (in order of sensitivity): 'none' (least), 'truncated', 'error' or 'warning' (most), higher levels imply lower levels, invalid metadata will always abort.
+ * @param {string} [options.failOn='warning'] - When to abort processing of invalid pixel data, one of (in order of sensitivity, least to most): 'none', 'truncated', 'error', 'warning'. Higher levels imply lower levels. Invalid metadata will always abort.
  * @param {number|boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
  *  (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
  *  An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
@@ -231,7 +230,8 @@ const Sharp = function (input, options) {
     threshold: 0,
     thresholdGrayscale: true,
     trimBackground: [],
-    trimThreshold: 0,
+    trimThreshold: -1,
+    trimLineArt: false,
     gamma: 0,
     gammaOut: 0,
     greyscale: false,
@@ -306,6 +306,7 @@ const Sharp = function (input, options) {
     tiffCompression: 'jpeg',
     tiffPredictor: 'horizontal',
     tiffPyramid: false,
+    tiffMiniswhite: false,
     tiffBitdepth: 8,
     tiffTile: false,
     tiffTileHeight: 256,

package/lib/index.d.ts

@@ -91,12 +91,6 @@ declare namespace sharp {
         zlib?: string | undefined;
     };
 
-    /** An Object containing the platform and architecture of the current and installed vendored binaries. */
-    const vendor: {
-        current: string;
-        installed: string[];
-    };
-
     /** An Object containing the available interpolators and their proper values */
     const interpolators: Interpolators;
 
@@ -139,6 +133,52 @@ declare namespace sharp {
      */
     function simd(enable?: boolean): boolean;
 
+    /**
+     * Block libvips operations at runtime.
+     *
+     * This is in addition to the `VIPS_BLOCK_UNTRUSTED` environment variable,
+     * which when set will block all "untrusted" operations.
+     *
+     * @since 0.32.4
+     *
+     * @example <caption>Block all TIFF input.</caption>
+     * sharp.block({
+     *   operation: ['VipsForeignLoadTiff']
+     * });
+     *
+     * @param {Object} options
+     * @param {Array<string>} options.operation - List of libvips low-level operation names to block.
+     */
+    function block(options: { operation: string[] }): void;
+
+    /**
+     * Unblock libvips operations at runtime.
+     *
+     * This is useful for defining a list of allowed operations.
+     *
+     * @since 0.32.4
+     *
+     * @example <caption>Block all input except WebP from the filesystem.</caption>
+     * sharp.block({
+     *   operation: ['VipsForeignLoad']
+     * });
+     * sharp.unblock({
+     *   operation: ['VipsForeignLoadWebpFile']
+     * });
+     *
+     * @example <caption>Block all input except JPEG and PNG from a Buffer or Stream.</caption>
+     * sharp.block({
+     *   operation: ['VipsForeignLoad']
+     * });
+     * sharp.unblock({
+     *   operation: ['VipsForeignLoadJpegBuffer', 'VipsForeignLoadPngBuffer']
+     * });
+     *
+     * @param {Object} options
+     * @param {Array<string>} options.operation - List of libvips low-level operation names to unblock.
+     */
+    function unblock(options: { operation: string[] }): void;
+
     //#endregion
 
     const gravity: GravityEnum;
@@ -600,7 +640,7 @@ declare namespace sharp {
          * @param withMetadata
          * @throws {Error} Invalid parameters.
          */
-        withMetadata(withMetadata?: WriteableMetadata): Sharp;
+        withMetadata(withMetadata?: boolean | WriteableMetadata): Sharp;
 
         /**
          * Use these JPEG options for output image.
@@ -659,7 +699,6 @@ declare namespace sharp {
 
         /**
          * Use these AVIF options for output image.
-         * Whilst it is possible to create AVIF images smaller than 16x16 pixels, most web browsers do not display these properly.
          * @param options Output options.
          * @throws {Error} Invalid options
          * @returns A sharp instance that can be used to chain operations
@@ -808,11 +847,11 @@ declare namespace sharp {
          * Trim pixels from all edges that contain values similar to the given background colour, which defaults to that of the top-left pixel.
          * Images with an alpha channel will use the combined bounding box of alpha and non-alpha channels.
          * The info response Object will contain trimOffsetLeft and trimOffsetTop properties.
-         * @param trim The specific background colour to trim, the threshold for doing so or an Object with both.
+         * @param options trim options
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        trim(trim?: string | number | TrimOptions): Sharp;
+        trim(options?: TrimOptions): Sharp;
 
         //#endregion
     }
@@ -1195,6 +1234,8 @@ declare namespace sharp {
         yres?: number | undefined;
         /** Reduce bitdepth to 1, 2 or 4 bit (optional, default 8) */
         bitdepth?: 1 | 2 | 4 | 8 | undefined;
+        /** Write 1-bit images as miniswhite (optional, default false) */
+        miniswhite?: boolean | undefined;
         /** Resolution unit options: inch, cm (optional, default 'inch') */
         resolutionUnit?: 'inch' | 'cm' | undefined;
     }
@@ -1236,10 +1277,10 @@ declare namespace sharp {
     }
 
     interface NormaliseOptions {
-      /** Percentile below which luminance values will be underexposed. */
-      lower?: number | undefined;
-      /** Percentile above which luminance values will be overexposed. */
-      upper?: number | undefined;
+        /** Percentile below which luminance values will be underexposed. */
+        lower?: number | undefined;
+        /** Percentile above which luminance values will be overexposed. */
+        upper?: number | undefined;
     }
 
     interface ResizeOptions {
@@ -1301,10 +1342,12 @@ declare namespace sharp {
     }
 
     interface TrimOptions {
-        /** background colour, parsed by the color module, defaults to that of the top-left pixel. (optional) */
+        /** Background colour, parsed by the color module, defaults to that of the top-left pixel. (optional) */
         background?: Color | undefined;
-        /** the allowed difference from the above colour, a positive number. (optional, default `10`) */
+        /** Allowed difference from the above colour, a positive number. (optional, default 10) */
         threshold?: number | undefined;
+        /** Does the input more closely resemble line art (e.g. vector) rather than being photographic? (optional, default false) */
+        lineArt?: boolean | undefined;
     }
 
     interface RawOptions {

package/lib/input.js

@@ -483,14 +483,27 @@ function _isStreamInput () {
  * @returns {Promise<Object>|Sharp}
  */
 function metadata (callback) {
+  const stack = Error();
   if (is.fn(callback)) {
     if (this._isStreamInput()) {
       this.on('finish', () => {
         this._flattenBufferIn();
-        sharp.metadata(this.options, callback);
+        sharp.metadata(this.options, (err, metadata) => {
+          if (err) {
+            callback(is.nativeError(err, stack));
+          } else {
+            callback(null, metadata);
+          }
+        });
       });
     } else {
-      sharp.metadata(this.options, callback);
+      sharp.metadata(this.options, (err, metadata) => {
+        if (err) {
+          callback(is.nativeError(err, stack));
+        } else {
+          callback(null, metadata);
+        }
+      });
     }
     return this;
   } else {
@@ -500,7 +513,7 @@ function metadata (callback) {
           this._flattenBufferIn();
           sharp.metadata(this.options, (err, metadata) => {
             if (err) {
-              reject(err);
+              reject(is.nativeError(err, stack));
             } else {
               resolve(metadata);
             }
@@ -516,7 +529,7 @@ function metadata (callback) {
       return new Promise((resolve, reject) => {
         sharp.metadata(this.options, (err, metadata) => {
           if (err) {
-            reject(err);
+            reject(is.nativeError(err, stack));
           } else {
             resolve(metadata);
           }
@@ -572,14 +585,27 @@ function metadata (callback) {
  * @returns {Promise<Object>}
  */
 function stats (callback) {
+  const stack = Error();
   if (is.fn(callback)) {
     if (this._isStreamInput()) {
       this.on('finish', () => {
         this._flattenBufferIn();
-        sharp.stats(this.options, callback);
+        sharp.stats(this.options, (err, stats) => {
+          if (err) {
+            callback(is.nativeError(err, stack));
+          } else {
+            callback(null, stats);
+          }
+        });
       });
     } else {
-      sharp.stats(this.options, callback);
+      sharp.stats(this.options, (err, stats) => {
+        if (err) {
+          callback(is.nativeError(err, stack));
+        } else {
+          callback(null, stats);
+        }
+      });
     }
     return this;
   } else {
@@ -589,7 +615,7 @@ function stats (callback) {
           this._flattenBufferIn();
           sharp.stats(this.options, (err, stats) => {
             if (err) {
-              reject(err);
+              reject(is.nativeError(err, stack));
             } else {
               resolve(stats);
             }
@@ -600,7 +626,7 @@ function stats (callback) {
       return new Promise((resolve, reject) => {
         sharp.stats(this.options, (err, stats) => {
           if (err) {
-            reject(err);
+            reject(is.nativeError(err, stack));
           } else {
             resolve(stats);
           }

package/lib/is.js

@@ -137,19 +137,33 @@ const invalidParameterError = function (name, expected, actual) {
   );
 };
 
+/**
+ * Ensures an Error from C++ contains a JS stack.
+ *
+ * @param {Error} native - Error with message from C++.
+ * @param {Error} context - Error with stack from JS.
+ * @returns {Error} Error with message and stack.
+ * @private
+ */
+const nativeError = function (native, context) {
+  context.message = native.message;
+  return context;
+};
+
 module.exports = {
-  defined: defined,
-  object: object,
-  plainObject: plainObject,
-  fn: fn,
-  bool: bool,
-  buffer: buffer,
-  typedArray: typedArray,
-  arrayBuffer: arrayBuffer,
-  string: string,
-  number: number,
-  integer: integer,
-  inRange: inRange,
-  inArray: inArray,
-  invalidParameterError: invalidParameterError
+  defined,
+  object,
+  plainObject,
+  fn,
+  bool,
+  buffer,
+  typedArray,
+  arrayBuffer,
+  string,
+  number,
+  integer,
+  inRange,
+  inArray,
+  invalidParameterError,
+  nativeError
 };

package/lib/libvips.js

@@ -3,61 +3,74 @@
 
 'use strict';
 
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const spawnSync = require('child_process').spawnSync;
+const { spawnSync } = require('node:child_process');
 const semverCoerce = require('semver/functions/coerce');
 const semverGreaterThanOrEqualTo = require('semver/functions/gte');
+const detectLibc = require('detect-libc');
 
-const platform = require('./platform');
-const { config } = require('../package.json');
+const { engines } = require('../package.json');
 
-const env = process.env;
-const minimumLibvipsVersionLabelled = env.npm_package_config_libvips || /* istanbul ignore next */
-  config.libvips;
+const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || /* istanbul ignore next */
+  engines.libvips;
 const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version;
 
+const prebuiltPlatforms = [
+  'darwin-arm64', 'darwin-x64',
+  'linux-arm', 'linux-arm64', 'linux-x64',
+  'linuxmusl-arm64', 'linuxmusl-x64',
+  'win32-ia32', 'win32-x64'
+];
+
 const spawnSyncOptions = {
   encoding: 'utf8',
   shell: true
 };
 
-const vendorPath = path.join(__dirname, '..', 'vendor', minimumLibvipsVersion, platform());
-
-const mkdirSync = function (dirPath) {
-  try {
-    fs.mkdirSync(dirPath, { recursive: true });
-  } catch (err) {
-    /* istanbul ignore next */
-    if (err.code !== 'EEXIST') {
-      throw err;
-    }
+const log = (item) => {
+  if (item instanceof Error) {
+    console.error(`sharp: Installation error: ${item.message}`);
+  } else {
+    console.log(`sharp: ${item}`);
   }
 };
 
-const cachePath = function () {
-  const npmCachePath = env.npm_config_cache || /* istanbul ignore next */
-    (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(os.homedir(), '.npm'));
-  mkdirSync(npmCachePath);
-  const libvipsCachePath = path.join(npmCachePath, '_libvips');
-  mkdirSync(libvipsCachePath);
-  return libvipsCachePath;
+/* istanbul ignore next */
+const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';
+
+const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;
+
+/* istanbul ignore next */
+const buildPlatformArch = () => {
+  /* eslint camelcase: ["error", { allow: ["^npm_config_"] }] */
+  const { npm_config_arch, npm_config_platform, npm_config_libc } = process.env;
+  return `${npm_config_platform || process.platform}${npm_config_libc || runtimeLibc()}-${npm_config_arch || process.arch}`;
 };
 
-const integrity = function (platformAndArch) {
-  return env[`npm_package_config_integrity_${platformAndArch.replace('-', '_')}`] || config.integrity[platformAndArch];
+const buildSharpLibvipsIncludeDir = () => {
+  try {
+    return require('@img/sharp-libvips-dev/include');
+  } catch {}
+  /* istanbul ignore next */
+  return '';
 };
 
-const log = function (item) {
-  if (item instanceof Error) {
-    console.error(`sharp: Installation error: ${item.message}`);
-  } else {
-    console.log(`sharp: ${item}`);
-  }
+const buildSharpLibvipsCPlusPlusDir = () => {
+  try {
+    return require('@img/sharp-libvips-dev/cplusplus');
+  } catch {}
+  /* istanbul ignore next */
+  return '';
+};
+
+const buildSharpLibvipsLibDir = () => {
+  try {
+    return require(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
+  } catch {}
+  /* istanbul ignore next */
+  return '';
 };
 
-const isRosetta = function () {
+const isRosetta = () => {
   /* istanbul ignore next */
   if (process.platform === 'darwin' && process.arch === 'x64') {
     const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
@@ -66,12 +79,19 @@ const isRosetta = function () {
   return false;
 };
 
-const globalLibvipsVersion = function () {
+/* istanbul ignore next */
+const spawnRebuild = () =>
+  spawnSync('node-gyp rebuild --directory=src', {
+    ...spawnSyncOptions,
+    stdio: 'inherit'
+  }).status;
+
+const globalLibvipsVersion = () => {
   if (process.platform !== 'win32') {
     const globalLibvipsVersion = spawnSync('pkg-config --modversion vips-cpp', {
       ...spawnSyncOptions,
       env: {
-        ...env,
+        ...process.env,
         PKG_CONFIG_PATH: pkgConfigPath()
       }
     }).stdout;
@@ -82,17 +102,8 @@ const globalLibvipsVersion = function () {
   }
 };
 
-const hasVendoredLibvips = function () {
-  return fs.existsSync(vendorPath);
-};
-
-/* istanbul ignore next */
-const removeVendoredLibvips = function () {
-  fs.rmSync(vendorPath, { recursive: true, maxRetries: 3, force: true });
-};
-
 /* istanbul ignore next */
-const pkgConfigPath = function () {
+const pkgConfigPath = () => {
   if (process.platform !== 'win32') {
     const brewPkgConfigPath = spawnSync(
       'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
@@ -100,7 +111,7 @@ const pkgConfigPath = function () {
     ).stdout || '';
     return [
       brewPkgConfigPath.trim(),
-      env.PKG_CONFIG_PATH,
+      process.env.PKG_CONFIG_PATH,
       '/usr/local/lib/pkgconfig',
       '/usr/lib/pkgconfig',
       '/usr/local/libdata/pkgconfig',
@@ -111,8 +122,9 @@ const pkgConfigPath = function () {
   }
 };
 
-const useGlobalLibvips = function () {
-  if (Boolean(env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+const useGlobalLibvips = () => {
+  if (Boolean(process.env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
+    log('Detected SHARP_IGNORE_GLOBAL_LIBVIPS, skipping search for globally-installed libvips');
     return false;
   }
   /* istanbul ignore next */
@@ -127,14 +139,15 @@ const useGlobalLibvips = function () {
 
 module.exports = {
   minimumLibvipsVersion,
-  minimumLibvipsVersionLabelled,
-  cachePath,
-  integrity,
+  prebuiltPlatforms,
+  buildPlatformArch,
+  buildSharpLibvipsIncludeDir,
+  buildSharpLibvipsCPlusPlusDir,
+  buildSharpLibvipsLibDir,
+  runtimePlatformArch,
   log,
+  spawnRebuild,
   globalLibvipsVersion,
-  hasVendoredLibvips,
-  removeVendoredLibvips,
   pkgConfigPath,
-  useGlobalLibvips,
-  mkdirSync
+  useGlobalLibvips
 };

package/lib/operation.js

@@ -19,7 +19,7 @@ const is = require('./is');
  * If no angle is provided, it is determined from the EXIF data.
  * Mirroring is supported and may infer the use of a flip operation.
  *
- * The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+ * The use of `rotate` without an angle will remove the EXIF `Orientation` tag, if any.
  *
  * Only one rotation can occur per pipeline.
  * Previous calls to `rotate` in the same pipeline will be ignored.
@@ -83,8 +83,6 @@ function rotate (angle, options) {
  * Mirror the image vertically (up-down) about the x-axis.
  * This always occurs before rotation, if any.
  *
- * The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
- *
  * This operation does not work correctly with multi-page images.
  *
  * @example
@@ -102,8 +100,6 @@ function flip (flip) {
  * Mirror the image horizontally (left-right) about the y-axis.
  * This always occurs before rotation, if any.
  *
- * The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
- *
  * @example
  * const output = await sharp(input).flop().toBuffer();
  *