nuxt-ignis 0.5.1 → 0.5.2

package/.output/server/node_modules/sharp/lib/input.js

@@ -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');
 
 /**
- * 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', 'unlimited',
+  // Format-generic
+  'animated', 'autoOrient', 'density', 'ignoreIcc', 'page', 'pages', 'sequentialRead',
+  // Format-specific
+  'jp2', 'openSlide', 'pdf', 'raw', 'svg', 'tiff',
+  // Deprecated
+  'failOnError', '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,9 @@ function _inputOptionsFromObject (obj) {
  */
 function _createInputDescriptor (input, inputOptions, containerOptions) {
   const inputDescriptor = {
+    autoOrient: false,
     failOn: 'warning',
-    limitInputPixels: Math.pow(0x3FFF, 2),
+    limitInputPixels: 0x3FFF ** 2,
     ignoreIcc: false,
     unlimited: false,
     sequentialRead: true
@@ -71,6 +88,18 @@ 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}` : ''
@@ -93,6 +122,14 @@ 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)) {
@@ -113,7 +150,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;
@@ -148,8 +185,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 +218,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 +260,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 +333,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');
         }
@@ -296,17 +407,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.width)) {
-          if (is.number(inputOptions.text.width)) {
+          if (is.integer(inputOptions.text.width) && inputOptions.text.width > 0) {
             inputDescriptor.textWidth = inputOptions.text.width;
           } else {
-            throw is.invalidParameterError('text.textWidth', 'number', inputOptions.text.width);
+            throw is.invalidParameterError('text.width', 'positive integer', inputOptions.text.width);
           }
         }
         if (is.defined(inputOptions.text.height)) {
-          if (is.number(inputOptions.text.height)) {
+          if (is.integer(inputOptions.text.height) && inputOptions.text.height > 0) {
             inputDescriptor.textHeight = inputOptions.text.height;
           } else {
-            throw is.invalidParameterError('text.height', 'number', inputOptions.text.height);
+            throw is.invalidParameterError('text.height', 'positive integer', inputOptions.text.height);
           }
         }
         if (is.defined(inputOptions.text.align)) {
@@ -324,10 +435,10 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.dpi)) {
-          if (is.number(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 100000)) {
+          if (is.integer(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 1000000)) {
             inputDescriptor.textDpi = inputOptions.text.dpi;
           } else {
-            throw is.invalidParameterError('text.dpi', 'number between 1 and 100000', inputOptions.text.dpi);
+            throw is.invalidParameterError('text.dpi', 'integer between 1 and 1000000', inputOptions.text.dpi);
           }
         }
         if (is.defined(inputOptions.text.rgba)) {
@@ -338,17 +449,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.spacing)) {
-          if (is.number(inputOptions.text.spacing)) {
+          if (is.integer(inputOptions.text.spacing) && is.inRange(inputOptions.text.spacing, -1000000, 1000000)) {
             inputDescriptor.textSpacing = inputOptions.text.spacing;
           } else {
-            throw is.invalidParameterError('text.spacing', 'number', inputOptions.text.spacing);
+            throw is.invalidParameterError('text.spacing', 'integer between -1000000 and 1000000', inputOptions.text.spacing);
           }
         }
         if (is.defined(inputOptions.text.wrap)) {
-          if (is.string(inputOptions.text.wrap) && is.inArray(inputOptions.text.wrap, ['word', 'char', 'wordChar', 'none'])) {
+          if (is.string(inputOptions.text.wrap) && is.inArray(inputOptions.text.wrap, ['word', 'char', 'word-char', 'none'])) {
             inputDescriptor.textWrap = inputOptions.text.wrap;
           } else {
-            throw is.invalidParameterError('text.wrap', 'one of: word, char, wordChar, none', inputOptions.text.wrap);
+            throw is.invalidParameterError('text.wrap', 'one of: word, char, word-char, none', inputOptions.text.wrap);
           }
         }
         delete inputDescriptor.buffer;
@@ -356,8 +467,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 +525,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,7 +570,7 @@ 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.
  *
@@ -424,21 +578,22 @@ function _isStreamInput () {
  * - `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,8 +603,10 @@ 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.
  *
  * @example
  * const metadata = await sharp(input).metadata();
@@ -469,28 +626,35 @@ 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}
  */
 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 +664,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 +680,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 +736,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 +766,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 +777,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);
           }
@@ -612,9 +789,10 @@ function stats (callback) {
 
 /**
  * Decorate the Sharp prototype with input-related functions.
+ * @module Sharp
  * @private
  */
-module.exports = function (Sharp) {
+module.exports = (Sharp) => {
   Object.assign(Sharp.prototype, {
     // Private
     _inputOptionsFromObject,