conductor-oss 0.61.21 → 0.61.22

package/web/.next/standalone/node_modules/sharp/{lib/input.js → dist/input.cjs}

@@ -3,8 +3,8 @@
   SPDX-License-Identifier: Apache-2.0
 */
 
-const is = require('./is');
-const sharp = require('./sharp');
+const is = require('./is.cjs');
+const sharp = require('./sharp.cjs');
 
 /**
  * Justification alignment
@@ -24,13 +24,13 @@ const align = {
 
 const inputStreamParameters = [
   // Limits and error handling
-  'failOn', 'limitInputPixels', 'unlimited',
+  'failOn', 'limitInputPixels', 'limitInputChannels', 'unlimited',
   // Format-generic
   'animated', 'autoOrient', 'density', 'ignoreIcc', 'page', 'pages', 'sequentialRead',
   // Format-specific
   'jp2', 'openSlide', 'pdf', 'raw', 'svg', 'tiff',
   // Deprecated
-  'failOnError', 'openSlideLevel', 'pdfBackground', 'tiffSubifd'
+  'openSlideLevel', 'pdfBackground', 'tiffSubifd'
 ];
 
 /**
@@ -55,6 +55,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     autoOrient: false,
     failOn: 'warning',
     limitInputPixels: 0x3FFF ** 2,
+    limitInputChannels: 5,
     ignoreIcc: false,
     unlimited: false,
     sequentialRead: true
@@ -106,14 +107,6 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }`);
   }
   if (is.object(inputOptions)) {
-    // Deprecated: failOnError
-    if (is.defined(inputOptions.failOnError)) {
-      if (is.bool(inputOptions.failOnError)) {
-        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
-      } else {
-        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
-      }
-    }
     // failOn
     if (is.defined(inputOptions.failOn)) {
       if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
@@ -132,7 +125,7 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     }
     // Density
     if (is.defined(inputOptions.density)) {
-      if (is.inRange(inputOptions.density, 1, 100000)) {
+      if (is.number(inputOptions.density) && is.inRange(inputOptions.density, 1, 100000)) {
         inputDescriptor.density = inputOptions.density;
       } else {
         throw is.invalidParameterError('density', 'number between 1 and 100000', inputOptions.density);
@@ -158,6 +151,16 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('limitInputPixels', 'positive integer', inputOptions.limitInputPixels);
       }
     }
+    // limitInputChannels
+    if (is.defined(inputOptions.limitInputChannels)) {
+      if (is.bool(inputOptions.limitInputChannels)) {
+        inputDescriptor.limitInputChannels = inputOptions.limitInputChannels ? 5 : 0;
+      } else if (is.integer(inputOptions.limitInputChannels) && is.inRange(inputOptions.limitInputChannels, 0, Number.MAX_SAFE_INTEGER)) {
+        inputDescriptor.limitInputChannels = inputOptions.limitInputChannels;
+      } else {
+        throw is.invalidParameterError('limitInputChannels', 'positive integer', inputOptions.limitInputChannels);
+      }
+    }
     // unlimited
     if (is.defined(inputOptions.unlimited)) {
       if (is.bool(inputOptions.unlimited)) {
@@ -574,7 +577,8 @@ function _isStreamInput () {
  *
  * A `Promise` is returned when `callback` is not provided.
  *
- * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
+ * - `format`: Name of decoder used to parse image e.g. `jpeg`, `png`, `webp`, `gif`, `svg`, `heif`, `tiff`
+ * - `mediaType`: Media Type (MIME Type) e.g. `image/jpeg`, `image/png`, `image/svg+xml`, `image/avif`
  * - `size`: Total size of image in bytes, for Stream and Buffer input only
  * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration, see example below)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
@@ -607,6 +611,7 @@ function _isStreamInput () {
  * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
  * - `formatMagick`: String containing format for images loaded via *magick
  * - `comments`: Array of keyword/text pairs representing PNG text blocks, if present.
+ * - `gainMap.image`: HDR gain map, if present, as compressed JPEG image.
  *
  * @example
  * const metadata = await sharp(input).metadata();

package/web/.next/standalone/node_modules/sharp/{lib/libvips.js → dist/libvips.cjs}

@@ -5,20 +5,18 @@
 
 const { spawnSync } = require('node:child_process');
 const { createHash } = require('node:crypto');
-const semverCoerce = require('semver/functions/coerce');
-const semverGreaterThanOrEqualTo = require('semver/functions/gte');
-const semverSatisfies = require('semver/functions/satisfies');
+const semver = require('semver');
 const detectLibc = require('detect-libc');
-
-const { config, engines, optionalDependencies } = require('../package.json');
+const pkg = require('../package.json');
 
 /* node:coverage ignore next */
-const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || config.libvips;
-const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version;
+const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || pkg.config.libvips;
+const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
 
 const prebuiltPlatforms = [
   'darwin-arm64', 'darwin-x64',
-  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-x64',
+  'freebsd-arm64', 'freebsd-x64',
+  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-wasm32', 'linux-x64',
   'linuxmusl-arm64', 'linuxmusl-x64',
   'win32-arm64', 'win32-ia32', 'win32-x64'
 ];
@@ -36,13 +34,13 @@ const log = (item) => {
   }
 };
 
-/* node:coverage ignore next */
+/* node:coverage disable */
+
 const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';
 
 const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;
 
 const buildPlatformArch = () => {
-  /* node:coverage ignore next 3 */
   if (isEmscripten()) {
     return 'wasm32';
   }
@@ -55,7 +53,6 @@ const buildSharpLibvipsIncludeDir = () => {
   try {
     return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/include`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require('@img/sharp-libvips-dev/include');
     } catch {}
@@ -64,7 +61,6 @@ const buildSharpLibvipsIncludeDir = () => {
 };
 
 const buildSharpLibvipsCPlusPlusDir = () => {
-  /* node:coverage ignore next 4 */
   try {
     return require('@img/sharp-libvips-dev/cplusplus');
   } catch {}
@@ -75,7 +71,6 @@ const buildSharpLibvipsLibDir = () => {
   try {
     return require(`@img/sharp-libvips-dev-${buildPlatformArch()}/lib`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
     } catch {}
@@ -83,12 +78,10 @@ const buildSharpLibvipsLibDir = () => {
   return '';
 };
 
-/* node:coverage disable */
-
 const isUnsupportedNodeRuntime = () => {
   if (process.release?.name === 'node' && process.versions) {
-    if (!semverSatisfies(process.versions.node, engines.node)) {
-      return { found: process.versions.node, expected: engines.node };
+    if (!semver.satisfies(process.versions.node, pkg.engines.node)) {
+      return { found: process.versions.node, expected: pkg.engines.node };
     }
   }
 };
@@ -113,7 +106,7 @@ const sha512 = (s) => createHash('sha512').update(s).digest('hex');
 const yarnLocator = () => {
   try {
     const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
-    const npmVersion = semverCoerce(optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
+    const npmVersion = semver.coerce(pkg.optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
       includePrerelease: true
     }).version;
     return sha512(`${identHash}npm:${npmVersion}`).slice(0, 10);
@@ -144,22 +137,34 @@ const globalLibvipsVersion = () => {
   }
 };
 
+const getBrewPkgConfigPath = () => {
+  try {
+    const brewPrefix = (spawnSync('brew', ['--prefix'], { encoding: 'utf8' }).stdout || '').trim();
+    if (brewPrefix) {
+      return `${brewPrefix}/lib/pkgconfig`;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
+const getPkgConfigPath = () => {
+  try {
+    const pkgConfigPath = (spawnSync('pkg-config', ['--variable', 'pc_path', 'pkg-config'], { encoding: 'utf8' }).stdout || '').trim();
+    if (pkgConfigPath) {
+      return pkgConfigPath;
+    }
+  } catch (_err) {}
+  return undefined;
+};
+
 /* node:coverage enable */
 
 const pkgConfigPath = () => {
   if (process.platform !== 'win32') {
-    /* node:coverage ignore next 4 */
-    const brewPkgConfigPath = spawnSync(
-      'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
-      spawnSyncOptions
-    ).stdout || '';
     return [
-      brewPkgConfigPath.trim(),
-      process.env.PKG_CONFIG_PATH,
-      '/usr/local/lib/pkgconfig',
-      '/usr/lib/pkgconfig',
-      '/usr/local/libdata/pkgconfig',
-      '/usr/libdata/pkgconfig'
+      getBrewPkgConfigPath(),
+      getPkgConfigPath(),
+      process.env.PKG_CONFIG_PATH
     ].filter(Boolean).join(':');
   } else {
     return '';
@@ -186,7 +191,7 @@ const useGlobalLibvips = (logger) => {
   }
   const globalVipsVersion = globalLibvipsVersion();
   /* node:coverage ignore next */
-  return !!globalVipsVersion && semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
+  return !!globalVipsVersion && semver.gte(globalVipsVersion, minimumLibvipsVersion);
 };
 
 module.exports = {

package/web/.next/standalone/node_modules/sharp/{lib/operation.js → dist/operation.cjs}

@@ -3,7 +3,7 @@
   SPDX-License-Identifier: Apache-2.0
 */
 
-const is = require('./is');
+const is = require('./is.cjs');
 
 /**
  * How accurate an operation should be.
@@ -178,7 +178,7 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = [].concat(...matrix);
+  const flatMatrix = Array.isArray(matrix) ? [].concat(...matrix) : [];
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -259,45 +259,18 @@ function affine (matrix, options) {
  *   })
  *   .toBuffer();
  *
- * @param {Object|number} [options] - if present, is an Object with attributes
+ * @param {Object} [options] - if present, is an Object with attributes
  * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`, between 0.000001 and 10
  * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas, between 0 and 1000000
  * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas, between 0 and 1000000
  * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged", between 0 and 1000000
  * @param {number} [options.y2=10.0] - maximum amount of brightening, between 0 and 1000000
  * @param {number} [options.y3=20.0] - maximum amount of darkening, between 0 and 1000000
- * @param {number} [flat] - (deprecated) see `options.m1`.
- * @param {number} [jagged] - (deprecated) see `options.m2`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
-function sharpen (options, flat, jagged) {
-  if (!is.defined(options)) {
-    // No arguments: default to mild sharpen
-    this.options.sharpenSigma = -1;
-  } else if (is.bool(options)) {
-    // Deprecated boolean argument: apply mild sharpen?
-    this.options.sharpenSigma = options ? -1 : 0;
-  } else if (is.number(options) && is.inRange(options, 0.01, 10000)) {
-    // Deprecated numeric argument: specific sigma
-    this.options.sharpenSigma = options;
-    // Deprecated control over flat areas
-    if (is.defined(flat)) {
-      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
-        this.options.sharpenM1 = flat;
-      } else {
-        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
-      }
-    }
-    // Deprecated control over jagged areas
-    if (is.defined(jagged)) {
-      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
-        this.options.sharpenM2 = jagged;
-      } else {
-        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
-      }
-    }
-  } else if (is.plainObject(options)) {
+function sharpen (options) {
+  if (is.plainObject(options)) {
     if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10)) {
       this.options.sharpenSigma = options.sigma;
     } else {
@@ -339,7 +312,7 @@ function sharpen (options, flat, jagged) {
       }
     }
   } else {
-    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
+    this.options.sharpenSigma = -1;
   }
   return this;
 }
@@ -510,8 +483,6 @@ function flatten (options) {
  *
  * Existing alpha channel values for non-white pixels remain unchanged.
  *
- * This feature is experimental and the API may change.
- *
  * @since 0.32.1
  *
  * @example

package/web/.next/standalone/node_modules/sharp/{lib/output.js → dist/output.cjs}

@@ -4,8 +4,8 @@
 */
 
 const path = require('node:path');
-const is = require('./is');
-const sharp = require('./sharp');
+const is = require('./is.cjs');
+const sharp = require('./sharp.cjs');
 
 const formats = new Map([
   ['heic', 'heif'],
@@ -76,7 +76,7 @@ function toFile (fileOut, callback) {
     err = new Error('Missing output file path');
   } else if (is.string(this.options.input.file) && path.resolve(this.options.input.file) === path.resolve(fileOut)) {
     err = new Error('Cannot use same file for input and output');
-  } else if (jp2Regex.test(path.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+  } else if (jp2Regex.test(path.extname(fileOut)) && !this.constructor.format.jp2.output.file) {
     err = errJp2Save();
   }
   if (err) {
@@ -164,6 +164,64 @@ function toBuffer (options, callback) {
   return this._pipeline(is.fn(options) ? options : callback, stack);
 }
 
+/**
+ * Write output to a `Uint8Array` backed by a transferable `ArrayBuffer`.
+ * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
+ *
+ * Use {@link #toformat toFormat} or one of the format-specific functions such as {@link #jpeg jpeg}, {@link #png png} etc. to set the output format.
+ *
+ * If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
+ *
+ * By default all metadata will be removed, which includes EXIF-based orientation.
+ * See {@link #keepexif keepExif} and similar methods for control over this.
+ *
+ * Resolves with an `Object` containing:
+ * - `data` is the output image as a `Uint8Array` backed by a transferable `ArrayBuffer`.
+ * - `info` contains properties relating to the output image such as `width` and `height`.
+ *
+ * @since v0.35.0
+ *
+ * @example
+ * const { data, info } = await sharp(input).toUint8Array();
+ *
+ * @example
+ * const { data } = await sharp(input)
+ *   .avif()
+ *   .toUint8Array();
+ * const base64String = data.toBase64();
+ *
+ * @returns {Promise<{ data: Uint8Array, info: Object }>}
+ */
+function toUint8Array () {
+  this.options.resolveWithObject = true;
+  this.options.typedArrayOut = true;
+  const stack = Error();
+  return this._pipeline(null, stack);
+}
+
+/**
+ * Set output density (DPI) in EXIF metadata.
+ *
+ * @since 0.35.0
+ *
+ * @example
+ * const data = await sharp(input)
+ *   .withDensity(96)
+ *   .toBuffer();
+ *
+ * @param {number} density Number of pixels per inch (DPI).
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function withDensity (density) {
+  if (is.number(density) && density > 0) {
+    this.options.withMetadataDensity = density;
+  } else {
+    throw is.invalidParameterError('density', 'positive number', density);
+  }
+  return this.keepExif();
+}
+
 /**
  * Keep all EXIF metadata from the input image in the output image.
  *
@@ -319,6 +377,60 @@ function withIccProfile (icc, options) {
   return this;
 }
 
+/**
+ * If the input contains gain map metadata, attempt to process the image and gain map separately,
+ * recombining them into a single output image.
+ *
+ * This approach is faster and should produce better results than {@link #withgainmap withGainMap},
+ * however not all operations are supported.
+ *
+ * Only JPEG input and output are supported.
+ * JPEG output options other than `quality` are ignored.
+ *
+ * This feature is experimental and the API may change.
+ *
+ * @since 0.35.0
+ *
+ * @example
+ * const outputWithResizedGainMap = await sharp(inputWithGainMap)
+ *   .keepGainMap()
+ *   .resize({ width: 64 })
+ *   .toBuffer();
+ *
+ * @returns {Sharp}
+ */
+function keepGainMap() {
+  this.options.keepGainMap = true;
+  this.options.withGainMap = false;
+  this.options.keepMetadata |= 0b100000;
+  return this;
+}
+
+/**
+ * If the input contains gain map metadata, use it to convert the main image to HDR (High Dynamic Range) before further processing.
+ * The input gain map is discarded.
+ *
+ * If the output is JPEG, generate and attach a new ISO 21496-1 gain map.
+ * JPEG output options other than `quality` are ignored.
+ *
+ * This feature is experimental and the API may change.
+ *
+ * @since 0.35.0
+ *
+ * @example
+ * const outputWithRegeneratedGainMap = await sharp(inputWithGainMap)
+ *   .withGainMap()
+ *   .toBuffer();
+ *
+ * @returns {Sharp}
+ */
+function withGainMap() {
+  this.options.withGainMap = true;
+  this.options.keepGainMap = false;
+  this.options.colourspace = 'scrgb';
+  return this;
+}
+
 /**
  * Keep XMP metadata from the input image in the output image.
  *
@@ -388,7 +500,7 @@ function withXmp (xmp) {
  * @returns {Sharp}
  */
 function keepMetadata () {
-  this.options.keepMetadata = 0b11111;
+  this.options.keepMetadata |= 0b11111;
   return this;
 }
 
@@ -690,6 +802,7 @@ function png (options) {
  * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
  * @param {boolean} [options.minSize=false] - prevent use of animation key frames to minimise file size (slow)
  * @param {boolean} [options.mixed=false] - allow mixture of lossy and lossless animation frames (slow)
+ * @param {boolean} [options.exact=false] - preserve the colour data in transparent pixels
  * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -742,6 +855,9 @@ function webp (options) {
     if (is.defined(options.mixed)) {
       this._setBooleanOption('webpMixed', options.mixed);
     }
+    if (is.defined(options.exact)) {
+      this._setBooleanOption('webpExact', options.exact);
+    }
   }
   trySetAnimationOptions(options, this.options);
   return this._updateFormatOut('webp', options);
@@ -887,7 +1003,7 @@ function gif (options) {
  */
 function jp2 (options) {
   /* node:coverage ignore next 41 */
-  if (!this.constructor.format.jp2k.output.buffer) {
+  if (!this.constructor.format.jp2.output.buffer) {
     throw errJp2Save();
   }
   if (is.object(options)) {
@@ -992,7 +1108,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
  * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
- * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit
  * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
  * @returns {Sharp}
  * @throws {Error} Invalid options
@@ -1007,10 +1123,10 @@ function tiff (options) {
       }
     }
     if (is.defined(options.bitdepth)) {
-      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {
+      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4])) {
         this.options.tiffBitdepth = options.bitdepth;
       } else {
-        throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);
+        throw is.invalidParameterError('bitdepth', '1, 2 or 4', options.bitdepth);
       }
     }
     // tiling
@@ -1090,10 +1206,8 @@ function tiff (options) {
  * Use these AVIF options for output image.
  *
  * AVIF image sequences are not supported.
- * Prebuilt binaries support a bitdepth of 8 only.
  *
- * This feature is experimental on the Windows ARM64 platform
- * and requires a CPU with ARM64v8.4 or later.
+ * When using Windows ARM64, this feature requires a CPU with ARM64v8.4 or later.
  *
  * @example
  * const data = await sharp(input)
@@ -1113,6 +1227,7 @@ function tiff (options) {
  * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
  * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
+ * @param {string} [options.tune='auto'] - tune output for a quality metric, one of 'auto' (default), 'iq', 'psnr' or 'ssim'
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -1140,6 +1255,7 @@ function avif (options) {
  * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
  * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
  * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
+ * @param {string} [options.tune='auto'] - tune output for a quality metric, one of 'auto' (default), 'iq', 'psnr' or 'ssim'
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -1180,14 +1296,22 @@ function heif (options) {
     }
     if (is.defined(options.bitdepth)) {
       if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [8, 10, 12])) {
-        if (options.bitdepth !== 8 && this.constructor.versions.heif) {
-          throw is.invalidParameterError('bitdepth when using prebuilt binaries', 8, options.bitdepth);
-        }
         this.options.heifBitdepth = options.bitdepth;
       } else {
         throw is.invalidParameterError('bitdepth', '8, 10 or 12', options.bitdepth);
       }
     }
+    if (is.defined(options.tune)) {
+      if (is.string(options.tune) && is.inArray(options.tune, ['auto', 'iq', 'psnr', 'ssim'])) {
+        if (this.options.heifLossless && options.tune === 'iq') {
+          this.options.heifTune = 'ssim';
+        } else {
+          this.options.heifTune = options.tune;
+        }
+      } else {
+        throw is.invalidParameterError('tune', 'one of: auto, iq, psnr, ssim', options.tune);
+      }
+    }
   } else {
     throw is.invalidParameterError('options', 'Object', options);
   }
@@ -1635,11 +1759,15 @@ module.exports = (Sharp) => {
     // Public
     toFile,
     toBuffer,
+    toUint8Array,
+    withDensity,
     keepExif,
     withExif,
     withExifMerge,
     keepIccProfile,
     withIccProfile,
+    keepGainMap,
+    withGainMap,
     keepXmp,
     withXmp,
     keepMetadata,

package/web/.next/standalone/node_modules/sharp/{lib/resize.js → dist/resize.cjs}

@@ -3,7 +3,7 @@
   SPDX-License-Identifier: Apache-2.0
 */
 
-const is = require('./is');
+const is = require('./is.cjs');
 
 /**
  * Weighting to apply when using contain/cover fit.
@@ -506,6 +506,8 @@ function extract (options) {
  *
  * If the result of this operation would trim an image to nothing then no change is made.
  *
+ * Use the `lineArt` and `threshold` options for control over sensitivity.
+ *
  * The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` properties.
  *
  * @example
@@ -540,10 +542,19 @@ function extract (options) {
  *   })
  *   .toBuffer();
  *
+ * @example
+ * // Trim image leaving (up to) a 10 pixel margin around the trimmed content.
+ * const output = await sharp(input)
+ *   .trim({
+ *     margin: 10
+ *   })
+ *   .toBuffer();
+ *
  * @param {Object} [options]
  * @param {string|Object} [options.background='top-left pixel'] - Background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to that of the top-left pixel.
  * @param {number} [options.threshold=10] - Allowed difference from the above colour, a positive number.
  * @param {boolean} [options.lineArt=false] - Does the input more closely resemble line art (e.g. vector) rather than being photographic?
+ * @param {number} [options.margin=0] - Leave a margin around trimmed content, value is in pixels.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -564,6 +575,13 @@ function trim (options) {
       if (is.defined(options.lineArt)) {
         this._setBooleanOption('trimLineArt', options.lineArt);
       }
+      if (is.defined(options.margin)) {
+        if (is.integer(options.margin) && options.margin >= 0) {
+          this.options.trimMargin = options.margin;
+        } else {
+          throw is.invalidParameterError('margin', 'positive integer', options.margin);
+        }
+      }
     } else {
       throw is.invalidParameterError('trim', 'object', options);
     }