@depup/sharp-cli 5.2.0-depup.0 → 5.3.0-depup.0

package/lib/cli.js

@@ -22,191 +22,205 @@
  */
 
 // Strict mode.
-'use strict'
+"use strict";
 
 // Package modules.
-const pick = require('lodash.pick')
-const sharp = require('sharp')
-const yargs = require('yargs')
+const pick = require("lodash.pick");
+const sharp = require("sharp");
+const yargs = require("yargs");
 
 // Local modules.
-const constants = require('./constants')
-const pkg = require('../package.json')
-const queue = require('./queue')
+const constants = require("./constants");
+const pkg = require("../package.json");
+const queue = require("./queue");
 
 // Configure.
-const IS_TEXT_TERMINAL = process.stdin.isTTY
+const IS_TEXT_TERMINAL = process.stdin.isTTY;
 
 // Options.
-const global = 'Global Options'
-const input = 'Input Options'
-const optimize = 'Optimization Options'
-const output = 'Output Options'
+const global = "Global Options";
+const input = "Input Options";
+const optimize = "Optimization Options";
+const output = "Output Options";
 
 const globalOptions = {
   // @see https://sharp.pixelplumbing.com/api-constructor/
   input: {
-    alias: 'i',
-    defaultDescription: 'stdin',
+    alias: "i",
+    defaultDescription: "stdin",
     demand: IS_TEXT_TERMINAL,
-    desc: 'Path to (an) image file(s)',
+    desc: "Path to (an) image file(s)",
     group: global,
-    implies: 'output',
-    type: 'array'
+    implies: "output",
+    type: "array",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output/
   output: {
-    alias: 'o',
-    defaultDescription: 'stdout',
+    alias: "o",
+    defaultDescription: "stdout",
     demand: IS_TEXT_TERMINAL,
-    desc: 'Directory or URI template to write the image files to',
+    desc: "Directory or URI template to write the image files to",
     group: global,
-    type: 'string'
+    type: "string",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#timeout
   timeout: {
-    desc: 'Number of seconds after which processing will be stopped',
+    desc: "Number of seconds after which processing will be stopped",
     group: global,
-    type: 'number'
-  }
-}
+    type: "number",
+  },
+};
 
 // @see https://sharp.pixelplumbing.com/api-constructor
 const inputOptions = {
   animated: {
-    desc: 'Read all frames/pages of an animated image',
+    desc: "Read all frames/pages of an animated image",
     group: input,
-    type: 'boolean'
+    type: "boolean",
   },
   autoOrient: {
-    desc: 'Rotate/flip the image to match EXIF Orientation, if any',
+    desc: "Rotate/flip the image to match EXIF Orientation, if any",
     group: input,
-    type: 'boolean'
+    type: "boolean",
   },
   failOn: {
     choices: constants.FAIL_ON,
-    defaultDescription: 'warning',
-    desc: 'Level of sensitivity to invalid images',
-    group: input
+    defaultDescription: "warning",
+    desc: "Level of sensitivity to invalid images",
+    group: input,
   },
   density: {
-    desc: 'DPI for vector images',
+    desc: "DPI for vector images",
     defaultDescription: 72,
     group: input,
-    type: 'number'
+    type: "number",
   },
   ignoreIcc: {
     default: false,
-    desc: 'Should the embedded ICC profile, if any, be ignored',
+    desc: "Should the embedded ICC profile, if any, be ignored",
     group: input,
-    type: 'boolean'
+    type: "boolean",
   },
   level: {
-    desc: 'Level to extract from a multi-level input (OpenSlide), zero based',
+    desc: "Level to extract from a multi-level input (OpenSlide), zero based",
     defaultDescription: 0,
     group: input,
-    type: 'number'
+    type: "number",
   },
   limitInputPixels: {
-    defaultDescription: 0x3FFF * 0x3FFF,
-    desc: 'Do not process input images where the number of pixels (width x height) exceeds this limit',
+    defaultDescription: 0x3fff * 0x3fff,
+    desc: "Do not process input images where the number of pixels (width x height) exceeds this limit",
     group: input,
-    type: 'number'
+    type: "number",
   },
   page: {
     defaultDescription: 0,
-    desc: 'Page number to start extracting from for multi-page input',
+    desc: "Page number to start extracting from for multi-page input",
     group: input,
-    type: 'number'
+    type: "number",
   },
   pages: {
     defaultDescription: 1,
-    desc: 'Number of pages to extract for multi-page input',
+    desc: "Number of pages to extract for multi-page input",
     group: input,
-    type: 'number'
+    type: "number",
   },
   pdfBackground: {
-    desc: 'Background colour to use when PDF is partially transparent',
+    desc: "Background colour to use when PDF is partially transparent",
     group: input,
-    type: 'string'
+    type: "string",
   },
   sequentialRead: {
     default: false,
-    desc: 'Use sequential rather than random access where possible',
+    desc: "Use sequential rather than random access where possible",
     group: input,
-    type: 'boolean'
+    type: "boolean",
   },
   subifd: {
     defaultDescription: -1,
-    desc: 'subIFD to extract for OME-TIFF',
+    desc: "subIFD to extract for OME-TIFF",
     group: input,
-    type: 'number'
+    type: "number",
   },
   unlimited: {
-    desc: 'Remove safety features that help prevent memory exhaustion',
+    desc: "Remove safety features that help prevent memory exhaustion",
     group: input,
-    type: 'boolean'
-  }
-}
+    type: "boolean",
+  },
+};
 
 const outputOptions = {
+  // @see https://sharp.pixelplumbing.com/api-output#tiff
+  bigtiff: {
+    desc: "Use BigTIFF variant",
+    group: output,
+    type: "boolean",
+  },
+
   // @see https://sharp.pixelplumbing.com/api-output#png
   compressionLevel: {
-    alias: 'c',
-    desc: 'zlib compression level',
+    alias: "c",
+    desc: "zlib compression level",
     defaultDescription: 6,
     group: output,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#toformat
   format: {
-    alias: 'f',
+    alias: "f",
     choices: constants.FORMAT,
-    defaultDescription: 'input',
-    desc: 'Force output to a given format',
-    group: output
+    defaultDescription: "input",
+    desc: "Force output to a given format",
+    group: output,
+  },
+
+  // @see https://sharp.pixelplumbing.com/api-output#gif
+  keepDuplicateFrames: {
+    desc: "Keep duplicate frames in the output instead of combining them",
+    group: output,
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#withmetadata
   metadata: {
-    alias: ['m', 'withMetadata'],
-    desc: 'Include all metadata (EXIF, XMP, IPTC) from the input image in the output image',
+    alias: ["m", "withMetadata"],
+    desc: "Include all metadata (EXIF, XMP, IPTC) from the input image in the output image",
     group: output,
-    type: 'boolean'
+    type: "boolean",
   },
-  'metadata.density': {
-    desc: 'Number of pixels per inch (DPI)',
+  "metadata.density": {
+    desc: "Number of pixels per inch (DPI)",
     group: output,
-    type: 'number'
+    type: "number",
   },
-  'metadata.exif': {
-    defaultDescription: '{}',
-    desc: 'Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data',
+  "metadata.exif": {
+    defaultDescription: "{}",
+    desc: "Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data",
     group: output,
-    type: 'object'
+    type: "object",
   },
-  'metadata.icc': {
-    defaultDescription: 'sRGB',
-    desc: 'Filesystem path to output ICC profile',
+  "metadata.icc": {
+    defaultDescription: "sRGB",
+    desc: "Filesystem path to output ICC profile",
     group: output,
-    type: 'string'
+    type: "string",
   },
-  'metadata.orientation': {
-    desc: 'Used to update the EXIF Orientation tag',
+  "metadata.orientation": {
+    desc: "Used to update the EXIF Orientation tag",
     group: output,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   // @see https://sharp.pixelplumbing.com/api-output#png
   progressive: {
-    alias: 'p',
-    desc: 'Use progressive (interlace) scan',
+    alias: "p",
+    desc: "Use progressive (interlace) scan",
     group: output,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#avif
@@ -214,79 +228,79 @@ const outputOptions = {
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   // @see https://sharp.pixelplumbing.com/api-output#webp
   quality: {
-    alias: 'q',
-    desc: 'Quality',
-    defaultDescription: '80',
+    alias: "q",
+    desc: "Quality",
+    defaultDescription: "80",
     group: output,
-    type: 'number'
-  }
-}
+    type: "number",
+  },
+};
 
 const optimizationOptions = {
   // @see https://sharp.pixelplumbing.com/api-output#png
   adaptiveFiltering: {
-    desc: 'Use adaptive row filtering',
+    desc: "Use adaptive row filtering",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   alphaQuality: {
-    desc: 'Quality of alpha layer',
-    defaultDescription: '80',
+    desc: "Quality of alpha layer",
+    defaultDescription: "80",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   bitdepth: {
     choices: [1, 2, 4, 8],
     defaultDescription: 8,
-    desc: 'Reduce bitdepth to 1, 2, or 4 bit',
-    group: optimize
+    desc: "Reduce bitdepth to 1, 2, or 4 bit",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#avif
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   chromaSubsampling: {
     desc: 'Set to "4:4:4" to prevent chroma subsampling when quality <= 90',
-    defaultDescription: '4:4:4 (AVIF) / 4:2:0',
+    defaultDescription: "4:4:4 (AVIF) / 4:2:0",
     group: optimize,
-    type: 'string'
+    type: "string",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
-  // @see https://sharp.dimens.io/api-output#png
+  // @see https://sharp.pixelplumbing.com/api-output#png
   colors: {
-    alias: 'colours',
+    alias: "colours",
     defaultDescription: 256,
-    desc: 'Maximum number of palette entries',
+    desc: "Maximum number of palette entries",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   compression: {
     choices: constants.TIFF_COMPRESSION,
-    default: 'jpeg',
-    desc: 'Compression options',
-    group: optimize
+    default: "jpeg",
+    desc: "Compression options",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
   delay: {
-    desc: 'Delay(s) between animation frames',
+    desc: "Delay(s) between animation frames",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
-  // @see https://sharp.dimens.io/api-output#png
+  // @see https://sharp.pixelplumbing.com/api-output#png
   dither: {
-    desc: 'Level of Floyd-Steinberg error diffusion',
-    defaultDescription: '1.0',
+    desc: "Level of Floyd-Steinberg error diffusion",
+    defaultDescription: "1.0",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#avif
@@ -295,326 +309,347 @@ const optimizationOptions = {
   // @see https://sharp.pixelplumbing.com/api-output#png
   // @see https://sharp.pixelplumbing.com/api-output#webp
   effort: {
-    defaultDescription: '7 (GIF, PNG) / 4',
-    desc: 'Level of CPU effort to reduce file size',
+    defaultDescription: "7 (GIF, PNG) / 4",
+    desc: "Level of CPU effort to reduce file size",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#heif
   hbitdepth: {
     choices: [8, 10, 12],
     defaultDescription: 8,
-    desc: 'Set bitdepth to 8, 10, or 12 bit',
-    group: optimize
+    desc: "Set bitdepth to 8, 10, or 12 bit",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#heif
   hcompression: {
     choices: constants.HEIF_COMPRESSION,
-    default: 'av1',
-    desc: 'Compression format',
-    group: optimize
+    default: "av1",
+    desc: "Compression format",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
   interFrameMaxError: {
-    desc: 'Maximum inter-frame error for transparency',
+    desc: "Maximum inter-frame error for transparency",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
   interPaletteMaxError: {
-    desc: 'Maximum inter-palette error for palette reuse',
+    desc: "Maximum inter-palette error for palette reuse",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
   loop: {
     default: 0,
-    desc: 'Number of animation iterations',
+    desc: "Number of animation iterations",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#avif
   // @see https://sharp.pixelplumbing.com/api-output#webp
   lossless: {
-    desc: 'Use lossless compression mode',
+    desc: "Use lossless compression mode",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   miniswhite: {
-    desc: 'Write 1-bit images as miniswhite',
+    desc: "Write 1-bit images as miniswhite",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   minSize: {
-    desc: 'Prevent use of animation key frames to minimize file size',
+    desc: "Prevent use of animation key frames to minimize file size",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   mixed: {
-    desc: 'Allow mixture of lossy and lossless animation frames',
+    desc: "Allow mixture of lossy and lossless animation frames",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   mozjpeg: {
-    desc: 'Use mozjpeg defaults',
+    desc: "Use mozjpeg defaults",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   nearLossless: {
-    desc: 'Use near_lossless compression mode',
+    desc: "Use near_lossless compression mode",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   optimise: {
-    alias: 'optimize',
-    desc: 'Apply optimiseScans, overshootDeringing, and trellisQuantisation',
+    alias: "optimize",
+    desc: "Apply optimiseScans, overshootDeringing, and trellisQuantisation",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   optimiseCoding: {
-    alias: 'optimizeCoding',
+    alias: "optimizeCoding",
     default: true,
-    desc: 'Optimise Huffman coding tables',
+    desc: "Optimise Huffman coding tables",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   optimiseScans: {
-    alias: 'optimizeScans',
-    desc: 'Optimise progressive scans',
+    alias: "optimizeScans",
+    desc: "Optimise progressive scans",
     group: optimize,
-    implies: 'progressive',
-    type: 'boolean'
+    implies: "progressive",
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   overshootDeringing: {
-    desc: 'Apply overshoot deringing',
+    desc: "Apply overshoot deringing",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
-  // @see https://sharp.dimens.io/api-output#png
+  // @see https://sharp.pixelplumbing.com/api-output#png
   palette: {
-    desc: 'Quantise to a palette-based image with alpha transparency support',
+    desc: "Quantise to a palette-based image with alpha transparency support",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   predictor: {
     choices: constants.TIFF_PREDICTOR,
-    default: 'horizontal',
-    desc: 'Compression predictor',
-    group: optimize
+    default: "horizontal",
+    desc: "Compression predictor",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   preset: {
     choices: constants.PRESETS,
-    default: 'default',
-    desc: 'Named preset for preprocessing/filtering',
-    group: optimize
+    default: "default",
+    desc: "Named preset for preprocessing/filtering",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   pyramid: {
-    desc: 'Write an image pyramid',
+    desc: "Write an image pyramid",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   quantisationTable: {
-    alias: 'quantizationTable',
-    defaultDescription: '0',
-    desc: 'Quantization table to use',
+    alias: "quantizationTable",
+    defaultDescription: "0",
+    desc: "Quantization table to use",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#gif
   reuse: {
-    alias: ['reoptimise', 'reoptimize'],
-    desc: 'Always generate new palettes (slow)',
+    alias: ["reoptimise", "reoptimize"],
+    desc: "Always generate new palettes (slow)",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output
   resolutionUnit: {
     choices: constants.RESOLUTION_UNIT,
-    defaultDescription: 'inch',
-    desc: 'Resolution unit',
-    group: optimize
+    defaultDescription: "inch",
+    desc: "Resolution unit",
+    group: optimize,
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   smartDeblock: {
-    desc: 'Auto-adjust the deblocking filter, can improve low contrast edges',
+    desc: "Auto-adjust the deblocking filter, can improve low contrast edges",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#webp
   smartSubsample: {
-    desc: 'High quality chroma subsampling',
+    desc: "High quality chroma subsampling",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tile
   tileBackground: {
-    defaultDescription: 'rgba(255, 255, 255, 1)',
-    desc: 'Background colour, parsed by the color module',
+    defaultDescription: "rgba(255, 255, 255, 1)",
+    desc: "Background colour, parsed by the color module",
     group: optimize,
-    type: 'string'
+    type: "string",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   tileHeight: {
-    desc: 'Vertical tile size',
+    desc: "Vertical tile size",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   tileWidth: {
-    desc: 'Horizontal tile size',
+    desc: "Horizontal tile size",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   trellisQuantisation: {
-    desc: 'Apply trellis quantisation',
+    desc: "Apply trellis quantisation",
     group: optimize,
-    type: 'boolean'
+    type: "boolean",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   xres: {
-    defaultDescription: '1.0',
-    desc: 'Horizontal resolution',
+    defaultDescription: "1.0",
+    desc: "Horizontal resolution",
     group: optimize,
-    type: 'number'
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   yres: {
-    defaultDescription: '1.0',
-    desc: 'Vertical resolution',
+    defaultDescription: "1.0",
+    desc: "Vertical resolution",
     group: optimize,
-    type: 'number'
-  }
-}
+    type: "number",
+  },
+};
 
 const options = {
   ...globalOptions,
   ...inputOptions,
   ...outputOptions,
-  ...optimizationOptions
-}
+  ...optimizationOptions,
+};
 
 // Configure.
 const cli = yargs
-  .parserConfiguration({ 'populate--': true })
+  .parserConfiguration({ "populate--": true })
   .strict()
-  .usage('$0 <options> [command..]')
+  .usage("$0 <options> [command..]")
   .options(options)
-  .example('$0 -i ./input.jpg -o ./out resize 300 200', 'out/input.jpg will be a 300 pixels wide and 200 pixels high image containing a scaled and cropped version of input.jpg')
-  .example('$0 -i ./input.jpg -o ./out -mq90 rotate 180 -- resize 300 -- flatten "#ff6600" -- composite ./overlay.png --gravity southeast -- sharpen', 'out/input.jpg will be an upside down, 300px wide, alpha channel flattened onto orange background, composited with overlay.png with SE gravity, sharpened, with metadata, 90% quality version of input.jpg')
-  .example('$0 -i ./input.jpg -o ./out --metadata', 'Include all metadata in the output image')
-  .example('$0 -i ./input.jpg -o ./out --metadata.exif.IFD0.Copyright "Wernham Hogg"', 'Set "IFD0-Copyright" in output EXIF metadata')
-  .example('$0 -i ./input.jpg -o ./out --metadata.density 96', 'Set output metadata to 96 DPI')
-  .epilog('For more information on available options, please visit https://sharp.pixelplumbing.com/')
+  .example(
+    "$0 -i ./input.jpg -o ./out resize 300 200",
+    "out/input.jpg will be a 300 pixels wide and 200 pixels high image containing a scaled and cropped version of input.jpg",
+  )
+  .example(
+    '$0 -i ./input.jpg -o ./out -mq90 rotate 180 -- resize 300 -- flatten "#ff6600" -- composite ./overlay.png --gravity southeast -- sharpen',
+    "out/input.jpg will be an upside down, 300px wide, alpha channel flattened onto orange background, composited with overlay.png with SE gravity, sharpened, with metadata, 90% quality version of input.jpg",
+  )
+  .example(
+    "$0 -i ./input.jpg -o ./out --metadata",
+    "Include all metadata in the output image",
+  )
+  .example(
+    '$0 -i ./input.jpg -o ./out --metadata.exif.IFD0.Copyright "Wernham Hogg"',
+    'Set "IFD0-Copyright" in output EXIF metadata',
+  )
+  .example(
+    "$0 -i ./input.jpg -o ./out --metadata.density 96",
+    "Set output metadata to 96 DPI",
+  )
+  .epilog(
+    "For more information on available options, please visit https://sharp.pixelplumbing.com/",
+  )
   .showHelpOnFail(false)
   .wrap(100)
 
   // Built-in options.
-  .help().alias('help', 'h')
-  .version(pkg.version).alias('version', 'v')
-  .group(['help', 'version'], 'Misc. Options')
+  .help()
+  .alias("help", "h")
+  .version(pkg.version)
+  .alias("version", "v")
+  .group(["help", "version"], "Misc. Options")
 
   // Commands.
   // Avoid `yargs.commandDir()` as it uses insertion order, not alphabetical.
-  .command(require('../cmd/operations/affine'))
-  .command(require('../cmd/channel-manipulation/bandbool'))
-  .command(require('../cmd/operations/blur'))
-  .command(require('../cmd/operations/boolean'))
-  .command(require('../cmd/operations/clahe'))
-  .command(require('../cmd/compositing/composite'))
-  .command(require('../cmd/operations/convolve'))
-  .command(require('../cmd/channel-manipulation/ensure-alpha'))
-  .command(require('../cmd/resizing/extend'))
-  .command(require('../cmd/resizing/extract'))
-  .command(require('../cmd/channel-manipulation/extract-channel'))
-  .command(require('../cmd/operations/flatten'))
-  .command(require('../cmd/operations/flip'))
-  .command(require('../cmd/operations/flop'))
-  .command(require('../cmd/operations/gamma'))
-  .command(require('../cmd/colour-manipulation/greyscale'))
-  .command(require('../cmd/channel-manipulation/join-channel'))
-  .command(require('../cmd/operations/linear'))
-  .command(require('../cmd/operations/median'))
-  .command(require('../cmd/operations/modulate'))
-  .command(require('../cmd/operations/negate'))
-  .command(require('../cmd/operations/normalise'))
-  .command(require('../cmd/colour-manipulation/pipeline-colourspace'))
-  .command(require('../cmd/operations/recomb'))
-  .command(require('../cmd/channel-manipulation/remove-alpha'))
-  .command(require('../cmd/resizing/resize'))
-  .command(require('../cmd/operations/rotate'))
-  .command(require('../cmd/operations/sharpen'))
-  .command(require('../cmd/operations/threshold'))
-  .command(require('../cmd/colour-manipulation/tint'))
-  .command(require('../cmd/output'))
-  .command(require('../cmd/colour-manipulation/tocolourspace'))
-  .command(require('../cmd/resizing/trim'))
-  .command(require('../cmd/operations/unflatten'))
+  .command(require("../cmd/operations/affine"))
+  .command(require("../cmd/channel-manipulation/bandbool"))
+  .command(require("../cmd/operations/blur"))
+  .command(require("../cmd/operations/boolean"))
+  .command(require("../cmd/operations/clahe"))
+  .command(require("../cmd/compositing/composite"))
+  .command(require("../cmd/operations/convolve"))
+  .command(require("../cmd/operations/dilate"))
+  .command(require("../cmd/channel-manipulation/ensure-alpha"))
+  .command(require("../cmd/operations/erode"))
+  .command(require("../cmd/resizing/extend"))
+  .command(require("../cmd/resizing/extract"))
+  .command(require("../cmd/channel-manipulation/extract-channel"))
+  .command(require("../cmd/operations/flatten"))
+  .command(require("../cmd/operations/flip"))
+  .command(require("../cmd/operations/flop"))
+  .command(require("../cmd/operations/gamma"))
+  .command(require("../cmd/colour-manipulation/greyscale"))
+  .command(require("../cmd/channel-manipulation/join-channel"))
+  .command(require("../cmd/operations/linear"))
+  .command(require("../cmd/operations/median"))
+  .command(require("../cmd/operations/modulate"))
+  .command(require("../cmd/operations/negate"))
+  .command(require("../cmd/operations/normalise"))
+  .command(require("../cmd/colour-manipulation/pipeline-colourspace"))
+  .command(require("../cmd/operations/recomb"))
+  .command(require("../cmd/channel-manipulation/remove-alpha"))
+  .command(require("../cmd/resizing/resize"))
+  .command(require("../cmd/operations/rotate"))
+  .command(require("../cmd/operations/sharpen"))
+  .command(require("../cmd/operations/threshold"))
+  .command(require("../cmd/colour-manipulation/tint"))
+  .command(require("../cmd/output"))
+  .command(require("../cmd/colour-manipulation/tocolourspace"))
+  .command(require("../cmd/resizing/trim"))
+  .command(require("../cmd/operations/unflatten"));
 
 // Helpers.
-const originalParse = cli.parse.bind(cli)
+const originalParse = cli.parse.bind(cli);
 const promisifiedParse = (...args) => {
   return new Promise((resolve, reject) => {
     originalParse(...args, (err, argv, output) => {
       if (err) {
-        reject(err)
+        reject(err);
       }
       if (argv.v || argv.help) {
-        reject(output)
+        reject(output);
       }
-      resolve(argv)
-    })
-  })
-}
+      resolve(argv);
+    });
+  });
+};
 
 // Exports.
-module.exports = cli
-module.exports.inputOptions = Object.keys(inputOptions)
-module.exports.parse = function recursiveParse (args, context = {}) {
-  return promisifiedParse(args, context).then(argv => {
+module.exports = cli;
+module.exports.inputOptions = Object.keys(inputOptions);
+module.exports.parse = function recursiveParse(args, context = {}) {
+  return promisifiedParse(args, context).then((argv) => {
     // Handle arguments.
     // NOTE Use queue.unshift to apply global options first.
 
@@ -623,74 +658,115 @@ module.exports.parse = function recursiveParse (args, context = {}) {
     // Require at least one input file.
     // NOTE: check here b/c https://github.com/yargs/yargs/issues/403
     if (argv.input && argv.input.length === 0) {
-      throw new Error('Not enough arguments following: i, input')
+      throw new Error("Not enough arguments following: i, input");
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#timeout
     if (argv.timeout) {
-      queue.unshift(['timeout', (sharp) => sharp.timeout({ seconds: argv.timeout })])
+      queue.unshift([
+        "timeout",
+        (sharp) => sharp.timeout({ seconds: argv.timeout }),
+      ]);
     }
 
     // Output options.
 
     // @see https://sharp.pixelplumbing.com/api-output#toformat
     if (argv.format) {
-      queue.unshift(['format', (sharp) => sharp.toFormat(argv.format, { compression: argv.hcompression })])
+      queue.unshift([
+        "format",
+        (sharp) =>
+          sharp.toFormat(argv.format, { compression: argv.hcompression }),
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#withmetadata
     if (argv.metadata) {
-      queue.unshift(['withMetadata', (sharp) => sharp.withMetadata(argv.metadata)])
+      queue.unshift([
+        "withMetadata",
+        (sharp) => sharp.withMetadata(argv.metadata),
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#heif
-    const { heif } = sharp.format
-    if (argv.hcompression !== optimizationOptions.hcompression.default || // HEIF-specific.
+    const { heif } = sharp.format;
+    if (
+      argv.hcompression !== optimizationOptions.hcompression.default || // HEIF-specific.
       // Ensure libheif is installed before applying generic options.
-      (heif.input && heif.input.file &&
-      (argv.effort || argv.hbitdepth || argv.lossless || argv.quality))) {
-      queue.unshift(['heif', (sharp) => {
-        return sharp.heif({
-          bitdepth: argv.hbitdepth,
-          compression: argv.hcompression,
-          effort: argv.effort,
-          force: false,
-          lossless: argv.lossless,
-          quality: argv.quality
-        })
-      }])
+      (heif.input &&
+        heif.input.file &&
+        (argv.effort !== undefined ||
+          argv.hbitdepth ||
+          argv.lossless ||
+          argv.quality))
+    ) {
+      queue.unshift([
+        "heif",
+        (sharp) => {
+          return sharp.heif({
+            bitdepth: argv.hbitdepth,
+            compression: argv.hcompression,
+            effort: argv.effort,
+            force: false,
+            lossless: argv.lossless,
+            quality: argv.quality,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#avif
-    if (argv.chromaSubsampling || argv.effort || argv.lossless || argv.quality) {
-      queue.unshift(['avif', (sharp) => {
-        return sharp.avif({
-          chromaSubsampling: argv.chromaSubsampling,
-          effort: argv.effort,
-          force: false,
-          lossless: argv.lossless,
-          quality: argv.quality
-        })
-      }])
+    if (
+      argv.chromaSubsampling ||
+      argv.effort !== undefined ||
+      argv.lossless ||
+      argv.quality
+    ) {
+      queue.unshift([
+        "avif",
+        (sharp) => {
+          return sharp.avif({
+            chromaSubsampling: argv.chromaSubsampling,
+            effort: argv.effort,
+            force: false,
+            lossless: argv.lossless,
+            quality: argv.quality,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#gif
-    if (argv.colors || argv.effort || argv.dither || argv.interFrameMaxError ||
-     argv.interPaletteMaxError || argv.loop || argv.delay || argv.progressive || argv.reuse) {
-      queue.unshift(['gif', (sharp) => {
-        return sharp.gif({
-          colors: argv.colors,
-          force: false,
-          effort: argv.effort,
-          dither: argv.dither,
-          interFrameMaxError: argv.interFrameMaxError,
-          interPaletteMaxError: argv.interPaletteMaxError,
-          loop: argv.loop,
-          delay: argv.delay,
-          progressive: argv.progressive,
-          reuse: argv.reuse
-        })
-      }])
+    if (
+      argv.colors ||
+      argv.effort !== undefined ||
+      argv.dither !== undefined ||
+      argv.interFrameMaxError ||
+      argv.interPaletteMaxError ||
+      argv.keepDuplicateFrames ||
+      argv.loop ||
+      argv.delay !== undefined ||
+      argv.progressive ||
+      argv.reuse
+    ) {
+      queue.unshift([
+        "gif",
+        (sharp) => {
+          return sharp.gif({
+            colors: argv.colors,
+            force: false,
+            effort: argv.effort,
+            dither: argv.dither,
+            interFrameMaxError: argv.interFrameMaxError,
+            interPaletteMaxError: argv.interPaletteMaxError,
+            keepDuplicateFrames: argv.keepDuplicateFrames,
+            loop: argv.loop,
+            delay: argv.delay,
+            progressive: argv.progressive,
+            reuse: argv.reuse,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#jpeg
@@ -706,95 +782,133 @@ module.exports.parse = function recursiveParse (args, context = {}) {
       argv.quality ||
       argv.trellisQuantisation
     ) {
-      queue.unshift(['jpeg', (sharp) => {
-        return sharp.jpeg({
-          chromaSubsampling: argv.chromaSubsampling,
-          force: false,
-          mozjpeg: argv.mozjpeg,
-          optimiseCoding: argv.optimiseCoding,
-          optimiseScans: argv.optimise || argv.optimiseScans,
-          overshootDeringing: argv.optimise || argv.overshootDeringing,
-          progressive: argv.progressive,
-          quality: argv.quality,
-          quantisationTable: argv.quantisationTable,
-          trellisQuantisation: argv.optimise || argv.trellisQuantisation
-        })
-      }])
+      queue.unshift([
+        "jpeg",
+        (sharp) => {
+          return sharp.jpeg({
+            chromaSubsampling: argv.chromaSubsampling,
+            force: false,
+            mozjpeg: argv.mozjpeg,
+            optimiseCoding: argv.optimiseCoding,
+            optimiseScans: argv.optimise || argv.optimiseScans,
+            overshootDeringing: argv.optimise || argv.overshootDeringing,
+            progressive: argv.progressive,
+            quality: argv.quality,
+            quantisationTable: argv.quantisationTable,
+            trellisQuantisation: argv.optimise || argv.trellisQuantisation,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#png
-    if (argv.adaptiveFiltering || argv.colors || argv.compressionLevel ||
-      argv.dither || argv.effort || argv.palette || argv.progressive) {
-      queue.unshift(['png', (sharp) => {
-        return sharp.png({
-          adaptiveFiltering: argv.adaptiveFiltering,
-          colors: argv.colors,
-          compressionLevel: argv.compressionLevel,
-          dither: argv.dither,
-          effort: argv.effort,
-          force: false,
-          palette: argv.palette,
-          progressive: argv.progressive
-        })
-      }])
+    if (
+      argv.adaptiveFiltering ||
+      argv.colors ||
+      argv.compressionLevel !== undefined ||
+      argv.dither !== undefined ||
+      argv.effort ||
+      argv.palette ||
+      argv.progressive
+    ) {
+      queue.unshift([
+        "png",
+        (sharp) => {
+          return sharp.png({
+            adaptiveFiltering: argv.adaptiveFiltering,
+            colors: argv.colors,
+            compressionLevel: argv.compressionLevel,
+            dither: argv.dither,
+            effort: argv.effort,
+            force: false,
+            palette: argv.palette,
+            progressive: argv.progressive,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#tiff
-    if (argv.bitdepth ||
+    if (
+      argv.bigtiff ||
+      argv.bitdepth ||
       argv.compression !== optimizationOptions.compression.default ||
       argv.predictor !== optimizationOptions.predictor.default ||
-      argv.miniswhite || argv.pyramid || argv.quality || argv.resolutionUnit ||
-      argv.tileBackground || argv.tileHeight || argv.tileWidth || argv.xres || argv.yres) {
-      queue.unshift(['tiff', (sharp) => {
-        return sharp.tiff({
-          background: argv.tileBackground,
-          bitdepth: argv.bitdepth,
-          compression: argv.compression,
-          force: false,
-          miniswhite: argv.miniswhite,
-          predictor: argv.predictor,
-          pyramid: argv.pyramid,
-          quality: argv.quality,
-          resolutionUnit: argv.resolutionUnit,
-          tile: argv.tileWidth !== undefined || argv.tileHeight !== undefined,
-          tileHeight: argv.tileHeight || argv.tileWidth,
-          tileWidth: argv.tileWidth || argv.tileHeight,
-          xres: argv.xres,
-          yres: argv.yres
-        })
-      }])
+      argv.miniswhite ||
+      argv.pyramid ||
+      argv.quality ||
+      argv.resolutionUnit ||
+      argv.tileBackground ||
+      argv.tileHeight ||
+      argv.tileWidth ||
+      argv.xres ||
+      argv.yres
+    ) {
+      queue.unshift([
+        "tiff",
+        (sharp) => {
+          return sharp.tiff({
+            background: argv.tileBackground,
+            bigtiff: argv.bigtiff,
+            bitdepth: argv.bitdepth,
+            compression: argv.compression,
+            force: false,
+            miniswhite: argv.miniswhite,
+            predictor: argv.predictor,
+            pyramid: argv.pyramid,
+            quality: argv.quality,
+            resolutionUnit: argv.resolutionUnit,
+            tile: argv.tileWidth !== undefined || argv.tileHeight !== undefined,
+            tileHeight: argv.tileHeight || argv.tileWidth,
+            tileWidth: argv.tileWidth || argv.tileHeight,
+            xres: argv.xres,
+            yres: argv.yres,
+          });
+        },
+      ]);
     }
 
     // @see https://sharp.pixelplumbing.com/api-output#webp
-    if (argv.alphaQuality || argv.quality || argv.lossless || argv.minSize ||
-      argv.mixed || argv.nearLossless || argv.effort ||
-      argv.preset !== optimizationOptions.preset.default || argv.smartDeblock ||
-      argv.smartSubsample) {
-      queue.unshift(['webp', (sharp) => {
-        return sharp.webp({
-          alphaQuality: argv.alphaQuality,
-          effort: argv.effort,
-          force: false,
-          lossless: argv.lossless,
-          minSize: argv.minSize,
-          mixed: argv.mixed,
-          nearLossless: argv.nearLossless,
-          preset: argv.preset,
-          quality: argv.quality,
-          smartDeblock: argv.smartDeblock,
-          smartSubsample: argv.smartSubsample
-        })
-      }])
+    if (
+      argv.alphaQuality ||
+      argv.quality ||
+      argv.lossless ||
+      argv.minSize ||
+      argv.mixed ||
+      argv.nearLossless ||
+      argv.effort !== undefined ||
+      argv.preset !== optimizationOptions.preset.default ||
+      argv.smartDeblock ||
+      argv.smartSubsample
+    ) {
+      queue.unshift([
+        "webp",
+        (sharp) => {
+          return sharp.webp({
+            alphaQuality: argv.alphaQuality,
+            effort: argv.effort,
+            force: false,
+            lossless: argv.lossless,
+            minSize: argv.minSize,
+            mixed: argv.mixed,
+            nearLossless: argv.nearLossless,
+            preset: argv.preset,
+            quality: argv.quality,
+            smartDeblock: argv.smartDeblock,
+            smartSubsample: argv.smartSubsample,
+          });
+        },
+      ]);
     }
 
     // Invoke with remaining arguments (if any).
-    const { '--': remainingargv = [] } = argv
+    const { "--": remainingargv = [] } = argv;
     if (remainingargv.length > 0) {
       return recursiveParse(remainingargv, {
         ...context,
-        ...pick(argv, Object.keys(options)) // Retain options.
-      })
+        ...pick(argv, Object.keys(options)), // Retain options.
+      });
     }
-    return argv
-  })
-}
+    return argv;
+  });
+};