sharp 0.33.5 → 0.35.0

package/{lib/input.js → dist/input.mjs}

@@ -1,32 +1,48 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
-'use strict';
-
-const color = require('color');
-const is = require('./is');
-const sharp = require('./sharp');
+import is from './is.mjs';
+import sharp from './sharp.mjs';
 
 /**
- * Justication alignment
+ * Justification alignment
  * @member
  * @private
  */
 const align = {
   left: 'low',
+  top: 'low',
+  low: 'low',
   center: 'centre',
   centre: 'centre',
-  right: 'high'
+  right: 'high',
+  bottom: 'high',
+  high: 'high'
 };
 
+const inputStreamParameters = [
+  // Limits and error handling
+  'failOn', 'limitInputPixels', 'limitInputChannels', 'unlimited',
+  // Format-generic
+  'animated', 'autoOrient', 'density', 'ignoreIcc', 'page', 'pages', 'sequentialRead',
+  // Format-specific
+  'jp2', 'openSlide', 'pdf', 'raw', 'svg', 'tiff',
+  // Deprecated
+  'openSlideLevel', 'pdfBackground', 'tiffSubifd'
+];
+
 /**
  * Extract input options, if any, from an object.
  * @private
  */
 function _inputOptionsFromObject (obj) {
-  const { raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd } = obj;
-  return [raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd].some(is.defined)
-    ? { raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd }
+  const params = inputStreamParameters
+    .filter(p => is.defined(obj[p]))
+    .map(p => ([p, obj[p]]));
+  return params.length
+    ? Object.fromEntries(params)
     : undefined;
 }
 
@@ -36,8 +52,10 @@ function _inputOptionsFromObject (obj) {
  */
 function _createInputDescriptor (input, inputOptions, containerOptions) {
   const inputDescriptor = {
+    autoOrient: false,
     failOn: 'warning',
-    limitInputPixels: Math.pow(0x3FFF, 2),
+    limitInputPixels: 0x3FFF ** 2,
+    limitInputChannels: 5,
     ignoreIcc: false,
     unlimited: false,
     sequentialRead: true
@@ -71,20 +89,24 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
     // Stream without options
     inputDescriptor.buffer = [];
+  } else if (Array.isArray(input)) {
+    if (input.length > 1) {
+      // Join images together
+      if (!this.options.joining) {
+        this.options.joining = true;
+        this.options.join = input.map(i => this._createInputDescriptor(i));
+      } else {
+        throw new Error('Recursive join is unsupported');
+      }
+    } else {
+      throw new Error('Expected at least two images to join');
+    }
   } else {
     throw new Error(`Unsupported input '${input}' of type ${typeof input}${
       is.defined(inputOptions) ? ` when also providing options of type ${typeof inputOptions}` : ''
     }`);
   }
   if (is.object(inputOptions)) {
-    // Deprecated: failOnError
-    if (is.defined(inputOptions.failOnError)) {
-      if (is.bool(inputOptions.failOnError)) {
-        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
-      } else {
-        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
-      }
-    }
     // failOn
     if (is.defined(inputOptions.failOn)) {
       if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
@@ -93,9 +115,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('failOn', 'one of: none, truncated, error, warning', inputOptions.failOn);
       }
     }
+    // autoOrient
+    if (is.defined(inputOptions.autoOrient)) {
+      if (is.bool(inputOptions.autoOrient)) {
+        inputDescriptor.autoOrient = inputOptions.autoOrient;
+      } else {
+        throw is.invalidParameterError('autoOrient', 'boolean', inputOptions.autoOrient);
+      }
+    }
     // Density
     if (is.defined(inputOptions.density)) {
-      if (is.inRange(inputOptions.density, 1, 100000)) {
+      if (is.number(inputOptions.density) && is.inRange(inputOptions.density, 1, 100000)) {
         inputDescriptor.density = inputOptions.density;
       } else {
         throw is.invalidParameterError('density', 'number between 1 and 100000', inputOptions.density);
@@ -113,7 +143,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (is.defined(inputOptions.limitInputPixels)) {
       if (is.bool(inputOptions.limitInputPixels)) {
         inputDescriptor.limitInputPixels = inputOptions.limitInputPixels
-          ? Math.pow(0x3FFF, 2)
+          ? 0x3FFF ** 2
           : 0;
       } else if (is.integer(inputOptions.limitInputPixels) && is.inRange(inputOptions.limitInputPixels, 0, Number.MAX_SAFE_INTEGER)) {
         inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
@@ -121,6 +151,16 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('limitInputPixels', 'positive integer', inputOptions.limitInputPixels);
       }
     }
+    // limitInputChannels
+    if (is.defined(inputOptions.limitInputChannels)) {
+      if (is.bool(inputOptions.limitInputChannels)) {
+        inputDescriptor.limitInputChannels = inputOptions.limitInputChannels ? 5 : 0;
+      } else if (is.integer(inputOptions.limitInputChannels) && is.inRange(inputOptions.limitInputChannels, 0, Number.MAX_SAFE_INTEGER)) {
+        inputDescriptor.limitInputChannels = inputOptions.limitInputChannels;
+      } else {
+        throw is.invalidParameterError('limitInputChannels', 'positive integer', inputOptions.limitInputChannels);
+      }
+    }
     // unlimited
     if (is.defined(inputOptions.unlimited)) {
       if (is.bool(inputOptions.unlimited)) {
@@ -148,8 +188,6 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.rawWidth = inputOptions.raw.width;
         inputDescriptor.rawHeight = inputOptions.raw.height;
         inputDescriptor.rawChannels = inputOptions.raw.channels;
-        inputDescriptor.rawPremultiplied = !!inputOptions.raw.premultiplied;
-
         switch (input.constructor) {
           case Uint8Array:
           case Uint8ClampedArray:
@@ -183,6 +221,25 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
       } else {
         throw new Error('Expected width, height and channels for raw pixel input');
       }
+      inputDescriptor.rawPremultiplied = false;
+      if (is.defined(inputOptions.raw.premultiplied)) {
+        if (is.bool(inputOptions.raw.premultiplied)) {
+          inputDescriptor.rawPremultiplied = inputOptions.raw.premultiplied;
+        } else {
+          throw is.invalidParameterError('raw.premultiplied', 'boolean', inputOptions.raw.premultiplied);
+        }
+      }
+      inputDescriptor.rawPageHeight = 0;
+      if (is.defined(inputOptions.raw.pageHeight)) {
+        if (is.integer(inputOptions.raw.pageHeight) && inputOptions.raw.pageHeight > 0 && inputOptions.raw.pageHeight <= inputOptions.raw.height) {
+          if (inputOptions.raw.height % inputOptions.raw.pageHeight !== 0) {
+            throw new Error(`Expected raw.height ${inputOptions.raw.height} to be a multiple of raw.pageHeight ${inputOptions.raw.pageHeight}`);
+          }
+          inputDescriptor.rawPageHeight = inputOptions.raw.pageHeight;
+        } else {
+          throw is.invalidParameterError('raw.pageHeight', 'positive integer', inputOptions.raw.pageHeight);
+        }
+      }
     }
     // Multi-page input (GIF, TIFF, PDF)
     if (is.defined(inputOptions.animated)) {
@@ -206,22 +263,68 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('page', 'integer between 0 and 100000', inputOptions.page);
       }
     }
-    // Multi-level input (OpenSlide)
-    if (is.defined(inputOptions.level)) {
+    // OpenSlide specific options
+    if (is.object(inputOptions.openSlide) && is.defined(inputOptions.openSlide.level)) {
+      if (is.integer(inputOptions.openSlide.level) && is.inRange(inputOptions.openSlide.level, 0, 256)) {
+        inputDescriptor.openSlideLevel = inputOptions.openSlide.level;
+      } else {
+        throw is.invalidParameterError('openSlide.level', 'integer between 0 and 256', inputOptions.openSlide.level);
+      }
+    } else if (is.defined(inputOptions.level)) {
+      // Deprecated
       if (is.integer(inputOptions.level) && is.inRange(inputOptions.level, 0, 256)) {
-        inputDescriptor.level = inputOptions.level;
+        inputDescriptor.openSlideLevel = inputOptions.level;
       } else {
         throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
       }
     }
-    // Sub Image File Directory (TIFF)
-    if (is.defined(inputOptions.subifd)) {
+    // TIFF specific options
+    if (is.object(inputOptions.tiff) && is.defined(inputOptions.tiff.subifd)) {
+      if (is.integer(inputOptions.tiff.subifd) && is.inRange(inputOptions.tiff.subifd, -1, 100000)) {
+        inputDescriptor.tiffSubifd = inputOptions.tiff.subifd;
+      } else {
+        throw is.invalidParameterError('tiff.subifd', 'integer between -1 and 100000', inputOptions.tiff.subifd);
+      }
+    } else if (is.defined(inputOptions.subifd)) {
+      // Deprecated
       if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
-        inputDescriptor.subifd = inputOptions.subifd;
+        inputDescriptor.tiffSubifd = inputOptions.subifd;
       } else {
         throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
       }
     }
+    // SVG specific options
+    if (is.object(inputOptions.svg)) {
+      if (is.defined(inputOptions.svg.stylesheet)) {
+        if (is.string(inputOptions.svg.stylesheet)) {
+          inputDescriptor.svgStylesheet = inputOptions.svg.stylesheet;
+        } else {
+          throw is.invalidParameterError('svg.stylesheet', 'string', inputOptions.svg.stylesheet);
+        }
+      }
+      if (is.defined(inputOptions.svg.highBitdepth)) {
+        if (is.bool(inputOptions.svg.highBitdepth)) {
+          inputDescriptor.svgHighBitdepth = inputOptions.svg.highBitdepth;
+        } else {
+          throw is.invalidParameterError('svg.highBitdepth', 'boolean', inputOptions.svg.highBitdepth);
+        }
+      }
+    }
+    // PDF specific options
+    if (is.object(inputOptions.pdf) && is.defined(inputOptions.pdf.background)) {
+      inputDescriptor.pdfBackground = this._getBackgroundColourOption(inputOptions.pdf.background);
+    } else if (is.defined(inputOptions.pdfBackground)) {
+      // Deprecated
+      inputDescriptor.pdfBackground = this._getBackgroundColourOption(inputOptions.pdfBackground);
+    }
+    // JPEG 2000 specific options
+    if (is.object(inputOptions.jp2) && is.defined(inputOptions.jp2.oneshot)) {
+      if (is.bool(inputOptions.jp2.oneshot)) {
+        inputDescriptor.jp2Oneshot = inputOptions.jp2.oneshot;
+      } else {
+        throw is.invalidParameterError('jp2.oneshot', 'boolean', inputOptions.jp2.oneshot);
+      }
+    }
     // Create new image
     if (is.defined(inputOptions.create)) {
       if (
@@ -233,39 +336,50 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.createWidth = inputOptions.create.width;
         inputDescriptor.createHeight = inputOptions.create.height;
         inputDescriptor.createChannels = inputOptions.create.channels;
+        inputDescriptor.createPageHeight = 0;
+        if (is.defined(inputOptions.create.pageHeight)) {
+          if (is.integer(inputOptions.create.pageHeight) && inputOptions.create.pageHeight > 0 && inputOptions.create.pageHeight <= inputOptions.create.height) {
+            if (inputOptions.create.height % inputOptions.create.pageHeight !== 0) {
+              throw new Error(`Expected create.height ${inputOptions.create.height} to be a multiple of create.pageHeight ${inputOptions.create.pageHeight}`);
+            }
+            inputDescriptor.createPageHeight = inputOptions.create.pageHeight;
+          } else {
+            throw is.invalidParameterError('create.pageHeight', 'positive integer', inputOptions.create.pageHeight);
+          }
+        }
         // Noise
         if (is.defined(inputOptions.create.noise)) {
           if (!is.object(inputOptions.create.noise)) {
             throw new Error('Expected noise to be an object');
           }
-          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+          if (inputOptions.create.noise.type !== 'gaussian') {
             throw new Error('Only gaussian noise is supported at the moment');
           }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
           if (!is.inRange(inputOptions.create.channels, 1, 4)) {
             throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
           }
-          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
-          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
-            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
-          } else {
-            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          inputDescriptor.createNoiseMean = 128;
+          if (is.defined(inputOptions.create.noise.mean)) {
+            if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+              inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+            } else {
+              throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+            }
           }
-          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
-            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
-          } else {
-            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          inputDescriptor.createNoiseSigma = 30;
+          if (is.defined(inputOptions.create.noise.sigma)) {
+            if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+              inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+            } else {
+              throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+            }
           }
         } else if (is.defined(inputOptions.create.background)) {
           if (!is.inRange(inputOptions.create.channels, 3, 4)) {
             throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
           }
-          const background = color(inputOptions.create.background);
-          inputDescriptor.createBackground = [
-            background.red(),
-            background.green(),
-            background.blue(),
-            Math.round(background.alpha() * 255)
-          ];
+          inputDescriptor.createBackground = this._getBackgroundColourOption(inputOptions.create.background);
         } else {
           throw new Error('Expected valid noise or background to create a new input image');
         }
@@ -356,8 +470,53 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw new Error('Expected a valid string to create an image with text.');
       }
     }
+    // Join images together
+    if (is.defined(inputOptions.join)) {
+      if (is.defined(this.options.join)) {
+        if (is.defined(inputOptions.join.animated)) {
+          if (is.bool(inputOptions.join.animated)) {
+            inputDescriptor.joinAnimated = inputOptions.join.animated;
+          } else {
+            throw is.invalidParameterError('join.animated', 'boolean', inputOptions.join.animated);
+          }
+        }
+        if (is.defined(inputOptions.join.across)) {
+          if (is.integer(inputOptions.join.across) && is.inRange(inputOptions.join.across, 1, 1000000)) {
+            inputDescriptor.joinAcross = inputOptions.join.across;
+          } else {
+            throw is.invalidParameterError('join.across', 'integer between 1 and 100000', inputOptions.join.across);
+          }
+        }
+        if (is.defined(inputOptions.join.shim)) {
+          if (is.integer(inputOptions.join.shim) && is.inRange(inputOptions.join.shim, 0, 1000000)) {
+            inputDescriptor.joinShim = inputOptions.join.shim;
+          } else {
+            throw is.invalidParameterError('join.shim', 'integer between 0 and 100000', inputOptions.join.shim);
+          }
+        }
+        if (is.defined(inputOptions.join.background)) {
+          inputDescriptor.joinBackground = this._getBackgroundColourOption(inputOptions.join.background);
+        }
+        if (is.defined(inputOptions.join.halign)) {
+          if (is.string(inputOptions.join.halign) && is.string(this.constructor.align[inputOptions.join.halign])) {
+            inputDescriptor.joinHalign = this.constructor.align[inputOptions.join.halign];
+          } else {
+            throw is.invalidParameterError('join.halign', 'valid alignment', inputOptions.join.halign);
+          }
+        }
+        if (is.defined(inputOptions.join.valign)) {
+          if (is.string(inputOptions.join.valign) && is.string(this.constructor.align[inputOptions.join.valign])) {
+            inputDescriptor.joinValign = this.constructor.align[inputOptions.join.valign];
+          } else {
+            throw is.invalidParameterError('join.valign', 'valid alignment', inputOptions.join.valign);
+          }
+        }
+      } else {
+        throw new Error('Expected input to be an array of images to join');
+      }
+    }
   } else if (is.defined(inputOptions)) {
-    throw new Error('Invalid input options ' + inputOptions);
+    throw new Error(`Invalid input options ${inputOptions}`);
   }
   return inputDescriptor;
 }
@@ -369,10 +528,8 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
  * @param {string} encoding - unused
  * @param {Function} callback
  */
-function _write (chunk, encoding, callback) {
-  /* istanbul ignore else */
+function _write (chunk, _encoding, callback) {
   if (Array.isArray(this.options.input.buffer)) {
-    /* istanbul ignore else */
     if (is.buffer(chunk)) {
       if (this.options.input.buffer.length === 0) {
         this.on('finish', () => {
@@ -416,29 +573,31 @@ function _isStreamInput () {
  * such as resize or rotate.
  *
  * Dimensions in the response will respect the `page` and `pages` properties of the
- * {@link /api-constructor#parameters|constructor parameters}.
+ * {@link /api-constructor/ 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`
+ * - `format`: Name of decoder used to parse image e.g. `jpeg`, `png`, `webp`, `gif`, `svg`, `heif`, `tiff`
+ * - `mediaType`: Media Type (MIME Type) e.g. `image/jpeg`, `image/png`, `image/svg+xml`, `image/avif`
  * - `size`: Total size of image in bytes, for Stream and Buffer input only
  * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration, see example below)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
- * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://www.libvips.org/API/current/VipsImage.html#VipsInterpretation)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://www.libvips.org/API/current/enum.Interpretation.html)
  * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
- * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://www.libvips.org/API/current/VipsImage.html#VipsBandFormat)
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://www.libvips.org/API/current/enum.BandFormat.html)
  * - `density`: Number of pixels per inch (DPI), if present
  * - `chromaSubsampling`: String containing JPEG chroma subsampling, `4:2:0` or `4:4:4` for RGB, `4:2:0:4` or `4:4:4:4` for CMYK
  * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
+ * - `isPalette`: Boolean indicating whether the image is palette-based (GIF, PNG).
+ * - `bitsPerSample`: Number of bits per sample for each channel (GIF, PNG, HEIF).
  * - `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
  * - `pageHeight`: Number of pixels high each page in a multi-page image will be.
- * - `paletteBitDepth`: Bit depth of palette-based image (GIF, PNG).
  * - `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
  * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
  * - `pagePrimary`: Number of the primary page in a HEIF image
  * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
  * - `subifds`: Number of Sub Image File Directories in an OME-TIFF image
- * - `background`: Default background colour, if present, for PNG (bKGD) and GIF images, either an RGB Object or a single greyscale value
+ * - `background`: Default background colour, if present, for PNG (bKGD) and GIF images
  * - `compression`: The encoder used to compress an HEIF file, `av1` (AVIF) or `hevc` (HEIC)
  * - `resolutionUnit`: The unit of resolution (density), either `inch` or `cm`, if present
  * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
@@ -448,9 +607,11 @@ function _isStreamInput () {
  * - `icc`: Buffer containing raw [ICC](https://www.npmjs.com/package/icc) profile data, if present
  * - `iptc`: Buffer containing raw IPTC data, if present
  * - `xmp`: Buffer containing raw XMP data, if present
+ * - `xmpAsString`: String containing XMP data, if valid UTF-8.
  * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
  * - `formatMagick`: String containing format for images loaded via *magick
  * - `comments`: Array of keyword/text pairs representing PNG text blocks, if present.
+ * - `gainMap.image`: HDR gain map, if present, as compressed JPEG image.
  *
  * @example
  * const metadata = await sharp(input).metadata();
@@ -470,15 +631,9 @@ function _isStreamInput () {
  *   });
  *
  * @example
- * // Based on EXIF rotation metadata, get the right-side-up width and height:
- *
- * const size = getNormalSize(await sharp(input).metadata());
- *
- * function getNormalSize({ width, height, orientation }) {
- *   return (orientation || 0) >= 5
- *     ? { width: height, height: width }
- *     : { width, height };
- * }
+ * // Get dimensions taking EXIF Orientation into account.
+ * const { autoOrient } = await sharp(input).metadata();
+ * const { width, height } = autoOrient;
  *
  * @param {Function} [callback] - called with the arguments `(err, metadata)`
  * @returns {Promise<Object>|Sharp}
@@ -639,9 +794,10 @@ function stats (callback) {
 
 /**
  * Decorate the Sharp prototype with input-related functions.
+ * @module Sharp
  * @private
  */
-module.exports = function (Sharp) {
+export default (Sharp) => {
   Object.assign(Sharp.prototype, {
     // Private
     _inputOptionsFromObject,

package/{lib/is.js → dist/is.cjs}

@@ -1,61 +1,49 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
-
-'use strict';
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 /**
  * Is this value defined and not null?
  * @private
  */
-const defined = function (val) {
-  return typeof val !== 'undefined' && val !== null;
-};
+const defined = (val) => typeof val !== 'undefined' && val !== null;
 
 /**
  * Is this value an object?
  * @private
  */
-const object = function (val) {
-  return typeof val === 'object';
-};
+const object = (val) => typeof val === 'object';
 
 /**
  * Is this value a plain object?
  * @private
  */
-const plainObject = function (val) {
-  return Object.prototype.toString.call(val) === '[object Object]';
-};
+const plainObject = (val) => Object.prototype.toString.call(val) === '[object Object]';
 
 /**
  * Is this value a function?
  * @private
  */
-const fn = function (val) {
-  return typeof val === 'function';
-};
+const fn = (val) => typeof val === 'function';
 
 /**
  * Is this value a boolean?
  * @private
  */
-const bool = function (val) {
-  return typeof val === 'boolean';
-};
+const bool = (val) => typeof val === 'boolean';
 
 /**
  * Is this value a Buffer object?
  * @private
  */
-const buffer = function (val) {
-  return val instanceof Buffer;
-};
+const buffer = (val) => val instanceof Buffer;
 
 /**
  * Is this value a typed array object?. E.g. Uint8Array or Uint8ClampedArray?
  * @private
  */
-const typedArray = function (val) {
+const typedArray = (val) => {
   if (defined(val)) {
     switch (val.constructor) {
       case Uint8Array:
@@ -78,49 +66,37 @@ const typedArray = function (val) {
  * Is this value an ArrayBuffer object?
  * @private
  */
-const arrayBuffer = function (val) {
-  return val instanceof ArrayBuffer;
-};
+const arrayBuffer = (val) => val instanceof ArrayBuffer;
 
 /**
  * Is this value a non-empty string?
  * @private
  */
-const string = function (val) {
-  return typeof val === 'string' && val.length > 0;
-};
+const string = (val) => typeof val === 'string' && val.length > 0;
 
 /**
  * Is this value a real number?
  * @private
  */
-const number = function (val) {
-  return typeof val === 'number' && !Number.isNaN(val);
-};
+const number = (val) => typeof val === 'number' && !Number.isNaN(val);
 
 /**
  * Is this value an integer?
  * @private
  */
-const integer = function (val) {
-  return Number.isInteger(val);
-};
+const integer = (val) => Number.isInteger(val);
 
 /**
  * Is this value within an inclusive given range?
  * @private
  */
-const inRange = function (val, min, max) {
-  return val >= min && val <= max;
-};
+const inRange = (val, min, max) => val >= min && val <= max;
 
 /**
  * Is this value within the elements of an array?
  * @private
  */
-const inArray = function (val, list) {
-  return list.includes(val);
-};
+const inArray = (val, list) => list.includes(val);
 
 /**
  * Create an Error with a message relating to an invalid parameter.
@@ -131,11 +107,9 @@ const inArray = function (val, list) {
  * @returns {Error} Containing the formatted message.
  * @private
  */
-const invalidParameterError = function (name, expected, actual) {
-  return new Error(
+const invalidParameterError = (name, expected, actual) => new Error(
     `Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`
   );
-};
 
 /**
  * Ensures an Error from C++ contains a JS stack.
@@ -145,7 +119,7 @@ const invalidParameterError = function (name, expected, actual) {
  * @returns {Error} Error with message and stack.
  * @private
  */
-const nativeError = function (native, context) {
+const nativeError = (native, context) => {
   context.message = native.message;
   return context;
 };