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

package/lib/cli.js

@@ -21,192 +21,297 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// Strict mode.
-'use strict'
-
 // Package modules.
-const pick = require('lodash.pick')
-const sharp = require('sharp')
-const yargs = require('yargs')
+import sharp from "sharp";
+import yargs from "yargs";
 
 // Local modules.
-const constants = require('./constants')
-const pkg = require('../package.json')
-const queue = require('./queue')
+import affine from "../cmd/operations/affine.js";
+import bandbool from "../cmd/channel-manipulation/bandbool.js";
+import blur from "../cmd/operations/blur.js";
+import boolean from "../cmd/operations/boolean.js";
+import clahe from "../cmd/operations/clahe.js";
+import composite from "../cmd/compositing/composite.js";
+import convolve from "../cmd/operations/convolve.js";
+import dilate from "../cmd/operations/dilate.js";
+import ensureAlpha from "../cmd/channel-manipulation/ensure-alpha.js";
+import erode from "../cmd/operations/erode.js";
+import extend from "../cmd/resizing/extend.js";
+import extract from "../cmd/resizing/extract.js";
+import extractChannel from "../cmd/channel-manipulation/extract-channel.js";
+import flatten from "../cmd/operations/flatten.js";
+import flip from "../cmd/operations/flip.js";
+import flop from "../cmd/operations/flop.js";
+import gamma from "../cmd/operations/gamma.js";
+import greyscale from "../cmd/colour-manipulation/greyscale.js";
+import joinChannel from "../cmd/channel-manipulation/join-channel.js";
+import linear from "../cmd/operations/linear.js";
+import median from "../cmd/operations/median.js";
+import modulate from "../cmd/operations/modulate.js";
+import negate from "../cmd/operations/negate.js";
+import normalise from "../cmd/operations/normalise.js";
+import pipelineColourspace from "../cmd/colour-manipulation/pipeline-colourspace.js";
+import recomb from "../cmd/operations/recomb.js";
+import removeAlpha from "../cmd/channel-manipulation/remove-alpha.js";
+import resize from "../cmd/resizing/resize.js";
+import rotate from "../cmd/operations/rotate.js";
+import sharpen from "../cmd/operations/sharpen.js";
+import threshold from "../cmd/operations/threshold.js";
+import tint from "../cmd/colour-manipulation/tint.js";
+import tile from "../cmd/output.js";
+import toColourspace from "../cmd/colour-manipulation/tocolourspace.js";
+import trim from "../cmd/resizing/trim.js";
+import unflatten from "../cmd/operations/unflatten.js";
+import constants from "./constants.js";
+import { pick } from "./utils.js";
+
+// Assets.
+import pkg from "../package.json" with { type: "json" };
 
 // 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 = {
+  dry: {
+    alias: "n",
+    desc: "Process images without writing output files",
+    group: global,
+    type: "boolean",
+  },
+
+  print: {
+    desc: "Print input and output metadata as JSON",
+    group: global,
+    implies: IS_TEXT_TERMINAL ? undefined : "dry",
+    type: "boolean",
+  },
+
   // @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",
+    requiresArg: true,
+    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'
+    nargs: 1,
+    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'
-  }
-}
+    nargs: 1,
+    type: "number",
+  },
+};
 
 // @see https://sharp.pixelplumbing.com/api-constructor
-const inputOptions = {
+export 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'
-  },
-  failOn: {
-    choices: constants.FAIL_ON,
-    defaultDescription: 'warning',
-    desc: 'Level of sensitivity to invalid images',
-    group: input
+    type: "boolean",
   },
   density: {
-    desc: 'DPI for vector images',
+    desc: "DPI for vector images",
     defaultDescription: 72,
     group: input,
-    type: 'number'
+    nargs: 1,
+    type: "number",
+  },
+  failOn: {
+    choices: constants.FAIL_ON,
+    defaultDescription: "warning",
+    desc: "Level of sensitivity to invalid images",
+    group: input,
   },
   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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    type: "number",
+  },
+  limitInputChannels: {
+    defaultDescription: 5,
+    desc: "Do not process input images where the number of channels exceeds this limit",
+    group: input,
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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#keepgainmap
+  keepGainMap: {
+    conflicts: "withGainMap",
+    desc: "Attempt to process the image and gain map separately, recombining them into a single output image",
+    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",
+  },
+  "metadata.density": {
+    desc: "Number of pixels per inch (DPI)",
     group: output,
-    type: 'boolean'
+    nargs: 1,
+    type: "number",
   },
-  'metadata.density': {
-    desc: 'Number of pixels per inch (DPI)',
+  "metadata.exif": {
+    defaultDescription: "{}",
+    desc: "Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data",
     group: output,
-    type: 'number'
+    type: "object",
   },
-  'metadata.exif': {
-    defaultDescription: '{}',
-    desc: 'Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data',
+  "metadata.icc": {
+    defaultDescription: "sRGB",
+    desc: "Filesystem path to output ICC profile",
     group: output,
-    type: 'object'
+    type: "string",
   },
-  'metadata.icc': {
-    defaultDescription: 'sRGB',
-    desc: 'Filesystem path to output ICC profile',
+  "metadata.orientation": {
+    desc: "Used to update the EXIF Orientation tag",
     group: output,
-    type: 'string'
+    nargs: 1,
+    type: "number",
   },
-  'metadata.orientation': {
-    desc: 'Used to update the EXIF Orientation tag',
+
+  // @see https://sharp.pixelplumbing.com/api-output#withdensity
+  withDensity: {
+    desc: "Set output density (DPI) in EXIF metadata",
     group: output,
-    type: 'number'
+    nargs: 1,
+    type: "number",
+  },
+
+  // @see https://sharp.pixelplumbing.com/api-output#withgainmap
+  withGainMap: {
+    conflicts: "keepGainMap",
+    desc: "Convert the main image to HDR (High Dynamic Range) before further processing",
+    group: output,
+    type: "boolean",
   },
 
   // @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 +319,85 @@ 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'
-  }
-}
+    nargs: 1,
+    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'
+    nargs: 1,
+    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,
+    nargs: 1,
   },
 
   // @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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#avif
@@ -295,389 +406,493 @@ 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,
+    nargs: 1,
+    type: "number",
+  },
+
+  // @see https://sharp.pixelplumbing.com/api-output#webp
+  exact: {
+    desc: "Preserve the colour data in transparent pixels",
     group: optimize,
-    type: 'number'
+    type: "boolean",
   },
 
   // @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,
+    nargs: 1,
   },
 
   // @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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    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'
+    nargs: 1,
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#tiff
   tileWidth: {
-    desc: 'Horizontal tile size',
+    desc: "Horizontal tile size",
     group: optimize,
-    type: 'number'
+    nargs: 1,
+    type: "number",
   },
 
   // @see https://sharp.pixelplumbing.com/api-output#jpeg
   trellisQuantisation: {
-    desc: 'Apply trellis quantisation',
+    desc: "Apply trellis quantisation",
+    group: optimize,
+    type: "boolean",
+  },
+
+  // @see https://sharp.pixelplumbing.com/api-output#avif
+  // @see https://sharp.pixelplumbing.com/api-output#heif
+  tune: {
+    choices: constants.TUNE,
+    defaultDescription: "auto",
+    desc: "Tune output for a quality metric",
     group: optimize,
-    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'
+    nargs: 1,
+    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'
-  }
-}
+    nargs: 1,
+    type: "number",
+  },
+};
 
 const options = {
   ...globalOptions,
   ...inputOptions,
   ...outputOptions,
-  ...optimizationOptions
+  ...optimizationOptions,
+};
+
+// Helpers.
+function createContext() {
+  return { "#queue": [] };
 }
 
 // Configure.
-const cli = yargs
-  .parserConfiguration({ 'populate--': true })
+const cli = yargs()
+  .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(affine)
+  .command(bandbool)
+  .command(blur)
+  .command(boolean)
+  .command(clahe)
+  .command(composite)
+  .command(convolve)
+  .command(dilate)
+  .command(ensureAlpha)
+  .command(erode)
+  .command(extend)
+  .command(extract)
+  .command(extractChannel)
+  .command(flatten)
+  .command(flip)
+  .command(flop)
+  .command(gamma)
+  .command(greyscale)
+  .command(joinChannel)
+  .command(linear)
+  .command(median)
+  .command(modulate)
+  .command(negate)
+  .command(normalise)
+  .command(pipelineColourspace)
+  .command(recomb)
+  .command(removeAlpha)
+  .command(resize)
+  .command(rotate)
+  .command(sharpen)
+  .command(threshold)
+  .command(tint)
+  .command(tile)
+  .command(toColourspace)
+  .command(trim)
+  .command(unflatten);
+
+// Intercept parsing as to orchestrate commands.
+cli.parseAsync = async function (args, context = createContext()) {
+  // Capture parsing result as a promise.
+  const argv = await new Promise((resolve, reject) => {
+    return cli.parse(args, context, (err, argv, output) => {
+      if (err) reject(err);
+      if (argv.help || argv.v) reject(output);
+      resolve(argv);
+    });
+  });
+
+  // Invoke with remaining arguments (if any). Carry over global options.
+  const remainingArgv = argv["--"] ?? [];
+  if (remainingArgv.length > 0) {
+    const globalArgv = pick(argv, Object.keys(options));
+    return cli.default(globalArgv).parseAsync(remainingArgv, context);
+  }
 
-// Helpers.
-const originalParse = cli.parse.bind(cli)
-const promisifiedParse = (...args) => {
-  return new Promise((resolve, reject) => {
-    originalParse(...args, (err, argv, output) => {
-      if (err) {
-        reject(err)
-      }
-      if (argv.v || argv.help) {
-        reject(output)
-      }
-      resolve(argv)
-    })
-  })
-}
+  // Apply global options (once).
+  const queue = context["#queue"];
+
+  // @see https://sharp.pixelplumbing.com/api-output#timeout
+  if (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 }),
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#keepgainmap
+  if (argv.keepGainMap) {
+    queue.unshift(["keepGainMap", (sharp) => sharp.keepGainMap()]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#withmetadata
+  if (argv.metadata) {
+    queue.unshift([
+      "withMetadata",
+      (sharp) => sharp.withMetadata(argv.metadata),
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#withdensity
+  if (argv.withDensity !== undefined) {
+    queue.unshift([
+      "withDensity",
+      (sharp) => sharp.withDensity(argv.withDensity),
+    ]);
+  }
 
-// Exports.
-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.
-
-    // Global options.
-
-    // 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')
-    }
-
-    // @see https://sharp.pixelplumbing.com/api-output#timeout
-    if (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 })])
-    }
-
-    // @see https://sharp.pixelplumbing.com/api-output#withmetadata
-    if (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.
-      // 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) => {
+  // @see https://sharp.pixelplumbing.com/api-output#withgainmap
+  if (argv.withGainMap) {
+    queue.unshift(["withGainMap", (sharp) => sharp.withGainMap()]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#heif
+  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 !== undefined ||
+        argv.hbitdepth ||
+        argv.lossless ||
+        argv.quality ||
+        argv.tune))
+  ) {
+    queue.unshift([
+      "heif",
+      (sharp, { format } = {}) => {
+        if (format && format !== "heif") return 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) => {
+          quality: argv.quality,
+          tune: argv.tune,
+        });
+      },
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#avif
+  if (
+    argv.chromaSubsampling ||
+    argv.effort !== undefined ||
+    argv.lossless ||
+    argv.quality ||
+    argv.tune
+  ) {
+    queue.unshift([
+      "avif",
+      (sharp, { format } = {}) => {
+        if (format && format !== "avif") return 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) => {
+          quality: argv.quality,
+          tune: argv.tune,
+        });
+      },
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#gif
+  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, { format } = {}) => {
+        if (format && format !== "gif") return sharp;
         return sharp.gif({
           colors: argv.colors,
           force: false,
@@ -685,28 +900,33 @@ module.exports.parse = function recursiveParse (args, context = {}) {
           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
-    if (
-      argv.chromaSubsampling ||
-      argv.mozjpeg ||
-      argv.optimise ||
-      argv.optimiseCoding !== true ||
-      argv.optimiseScans ||
-      argv.overshootDeringing ||
-      argv.progressive ||
-      argv.quantisationTable ||
-      argv.quality ||
-      argv.trellisQuantisation
-    ) {
-      queue.unshift(['jpeg', (sharp) => {
+          reuse: argv.reuse,
+        });
+      },
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#jpeg
+  if (
+    argv.chromaSubsampling ||
+    argv.mozjpeg ||
+    argv.optimise ||
+    argv.optimiseCoding !== true ||
+    argv.optimiseScans ||
+    argv.overshootDeringing ||
+    argv.progressive ||
+    argv.quantisationTable ||
+    argv.quality ||
+    argv.trellisQuantisation
+  ) {
+    queue.unshift([
+      "jpeg",
+      (sharp, { format } = {}) => {
+        if (format && format !== "jpeg") return sharp;
         return sharp.jpeg({
           chromaSubsampling: argv.chromaSubsampling,
           force: false,
@@ -717,15 +937,26 @@ module.exports.parse = function recursiveParse (args, context = {}) {
           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) => {
+          trellisQuantisation: argv.optimise || argv.trellisQuantisation,
+        });
+      },
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#png
+  if (
+    argv.adaptiveFiltering ||
+    argv.colors ||
+    argv.compressionLevel !== undefined ||
+    argv.dither !== undefined ||
+    argv.effort ||
+    argv.palette ||
+    argv.progressive
+  ) {
+    queue.unshift([
+      "png",
+      (sharp, { format } = {}) => {
+        if (format && format !== "png") return sharp;
         return sharp.png({
           adaptiveFiltering: argv.adaptiveFiltering,
           colors: argv.colors,
@@ -734,20 +965,35 @@ module.exports.parse = function recursiveParse (args, context = {}) {
           effort: argv.effort,
           force: false,
           palette: argv.palette,
-          progressive: argv.progressive
-        })
-      }])
-    }
-
-    // @see https://sharp.pixelplumbing.com/api-output#tiff
-    if (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) => {
+          progressive: argv.progressive,
+        });
+      },
+    ]);
+  }
+
+  // @see https://sharp.pixelplumbing.com/api-output#tiff
+  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, { format } = {}) => {
+        if (format && format !== "tiff") return sharp;
         return sharp.tiff({
           background: argv.tileBackground,
+          bigtiff: argv.bigtiff,
           bitdepth: argv.bitdepth,
           compression: argv.compression,
           force: false,
@@ -760,20 +1006,34 @@ module.exports.parse = function recursiveParse (args, context = {}) {
           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) => {
+          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 !== undefined ||
+    argv.exact ||
+    argv.preset !== optimizationOptions.preset.default ||
+    argv.smartDeblock ||
+    argv.smartSubsample
+  ) {
+    queue.unshift([
+      "webp",
+      (sharp, { format } = {}) => {
+        if (format && format !== "webp") return sharp;
         return sharp.webp({
           alphaQuality: argv.alphaQuality,
           effort: argv.effort,
+          exact: argv.exact,
           force: false,
           lossless: argv.lossless,
           minSize: argv.minSize,
@@ -782,19 +1042,13 @@ module.exports.parse = function recursiveParse (args, context = {}) {
           preset: argv.preset,
           quality: argv.quality,
           smartDeblock: argv.smartDeblock,
-          smartSubsample: argv.smartSubsample
-        })
-      }])
-    }
-
-    // Invoke with remaining arguments (if any).
-    const { '--': remainingargv = [] } = argv
-    if (remainingargv.length > 0) {
-      return recursiveParse(remainingargv, {
-        ...context,
-        ...pick(argv, Object.keys(options)) // Retain options.
-      })
-    }
-    return argv
-  })
-}
+          smartSubsample: argv.smartSubsample,
+        });
+      },
+    ]);
+  }
+
+  return argv;
+};
+
+export default cli;