* Composite image(s) over the processed (resized, extracted etc.) image. * * The images to composite must be the same size or smaller than the proce

* @param {string} input * @returns {string}

* Alternative spelling of greyscale(). * @param grayscale true to enable and false to disable (defaults to true) * @returns A sharp

* Keep all XMP metadata from the input image in the output image. * @returns A sharp instance that can be used to chain operations

* Alternative spelling of pipelineColourspace * @param colorspace pipeline colourspace e.g. rgb16, scrgb, lab, grey16 ... * @throws

* Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel. * @returns A sharp instance that can be used to

* Resize image to `width`, `height` or `width x height`. * * When both a `width` and `height` are provided, the possible methods by which the image

* Create Object containing input and input-related options. * @private

* Flattens the array of chunks accumulated in input.buffer. * @private

* Are we expecting Stream-based input? * @private * @returns {boolean}

* Invoke the C++ image processing pipeline * Supports callback, stream and promise variants * @private

* Called by a WriteableStream to notify us it is ready for data. * @private

* Update a colour attribute of the this.options Object. * @private * @param {string} key * @param {string|Object} value * @throws {Error} Invalid

* Update a boolean attribute of the this.options Object. * @private * @param {string} key * @param {boolean} val * @throws {Error} Invalid key

* Update the output format unless options.force is false, * in which case revert to input format. * @private * @param {string} formatOut * @param

* Handle incoming Buffer chunk on Writable Stream. * @private * @param {Buffer} chunk * @param {string} encoding - unused * @param {Function} call

* Perform an affine transform on an image. This operation will always occur after resizing, extraction and rotation, if any. * * You must provide an

* Auto-orient based on the EXIF `Orientation` tag, then remove the tag. * Mirroring is supported and may infer the use of a flip operation. * * Pre

* Use these AVIF options for output image. * * AVIF image sequences are not supported. * * @example * const data = await sharp(input) * .avif(

* Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image. * * @example * sharp('3-channel

* Block libvips operations at runtime. * * This is in addition to the `VIPS_BLOCK_UNTRUSTED` environment variable, * which when set will block all

* Blur the image. * * When used without parameters, performs a fast 3x3 box blur (equivalent to a box linear filter). * * When a `sigma` is provid

* Perform a bitwise boolean operation with operand image. * * This operation creates an output image where each pixel is the result of * the select

* Perform contrast limiting adaptive histogram equalization * {@link https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_A

* Take a "snapshot" of the Sharp instance, returning a new instance. * Cloned instances inherit the input of their parent instance. * This allows mu

* Gets or, when a concurrency is provided, sets * the maximum number of threads _libvips_ should use to process _each image_. * These are from a thr

* Convolve the image with the specified kernel. * * @example * sharp(input) * .convolve({ * width: 3, * height: 3, * kernel: [-1,

* Provides access to internal task counters. * - queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread f

* Expand foreground objects using the dilate morphological operator. * * @example * const output = await sharp(input) * .dilate() * .toBuffer

* Ensure the output image has an alpha transparency channel. * If missing, the added alpha channel will have the specified * transparency level, def

* Shrink foreground objects using the erode morphological operator. * * @example * const output = await sharp(input) * .erode() * .toBuffer()

* Extend / pad / extrude one or more edges of the image with either * the provided background colour or pixels derived from the image. * This operat

* Extract/crop a region of the image. * * - Use `extract` before `resize` for pre-resize extraction. * - Use `extract` after `resize` for post-resi

* Extract a single channel from a multi-channel image. * * The output colourspace will be either `b-w` (8-bit) or `grey16` (16-bit). * * @example

* Merge alpha transparency channel, if any, with a background, then remove the alpha channel. * * See also {@link /api-channel#removealpha removeAlp

* Mirror the image vertically (up-down) about the x-axis. * This always occurs before rotation, if any. * * This operation does not work correctly

* Mirror the image horizontally (left-right) about the y-axis. * This always occurs before rotation, if any. * * @example * const output = await s

* Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma` * then increasing the encoding (brighten) post-resiz

* Use these GIF options for the output image. * * The first entry in the palette is reserved for transparency. * * The palette of the input image

* Alternative spelling of `greyscale`. * @param {Boolean} [grayscale=true] * @returns {Sharp}

* Convert to 8-bit greyscale; 256 shades of grey. * This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use

* Use these HEIF options for output image. * * Support for patent-encumbered HEIC images using `hevc` compression requires the use of a * globally-

* Join one or more channels to the image. * The meaning of the added channels depends on the output colourspace, set with `toColourspace()`. * By de

* Use these JP2 options for output image. * * Requires libvips compiled with support for OpenJPEG. * The prebuilt binaries do not include this - se

* Use these JPEG options for output image. * * @example * // Convert any input to very high quality JPEG output * const data = await sharp(input)

* Use these JPEG-XL (JXL) options for output image. * * This feature is experimental, please do not use in production systems. * * Requires libvip

* Keep all EXIF metadata from the input image in the output image. * * EXIF metadata is unsupported for TIFF output. * * @since 0.33.0 * * @exam

* If the input contains gain map metadata, attempt to process the image and gain map separately, * recombining them into a single output image. * *

* Keep ICC profile from the input image in the output image. * * When input and output colour spaces differ, use with {@link /api-colour/#tocoloursp

* Keep all metadata (EXIF, ICC, XMP, IPTC) from the input image in the output image. * * The default behaviour, when `keepMetadata` is not used, is

* Keep XMP metadata from the input image in the output image. * * @since 0.34.3 * * @example * const outputWithXmp = await sharp(inputWithXmp) *

* Apply the linear formula `a` * input + `b` to the image to adjust image levels. * * When a single number is provided, it will be used for all imag

* Apply median filter. * When used without parameters the default window is 3x3. * * @example * const output = await sharp(input).median().toBuffe

* Fast access to (uncached) image metadata without decoding any compressed pixel data. * * This is read from the header of the input image. * It do

* Transforms the image using brightness, saturation, hue rotation, and lightness. * Brightness and lightness both operate on luminance, with the diff

* Produce the "negative" of the image. * * @example * const output = await sharp(input) * .negate() * .toBuffer(); * * @example * const ou

* Enhance output image contrast by stretching its luminance to cover a full dynamic range. * * Uses a histogram-based approach, taking a default ran

* Alternative spelling of normalise. * * @example * const output = await sharp(input) * .normalize() * .toBuffer(); * * @param {Object} [op

* Alternative spelling of `pipelineColourspace`. * @param {string} [colorspace] - pipeline colorspace. * @returns {Sharp} * @throws {Error} Invalid

* Set the pipeline colourspace. * * The input image will be converted to the provided colourspace at the start of the pipeline. * All operations wi

* Use these PNG options for output image. * * By default, PNG output is full colour at 8 bits per pixel. * * Indexed PNG input at 1, 2 or 4 bits p

* Force output to be raw, uncompressed pixel data. * Pixel ordering is left-to-right, top-to-bottom, without padding. * Channel ordering will be RGB

* Recombine the image with the specified matrix. * * @since 0.21.1 * * @example * sharp(input) * .recomb([ * [0.3588, 0.7044, 0.1368], *

* Remove alpha channels, if any. This is a no-op if the image does not have an alpha channel. * * See also {@link /api-operation/#flatten flatten}.

* Rotate the output image. * * The provided angle is converted to a valid positive degree rotation. * For example, `-450` will produce a 270 degree

* Sharpen the image. * * When used without parameters, performs a fast, mild sharpen of the output image. * * When a `sigma` is provided, performs

* Get and set use of SIMD vector unit instructions. * Requires libvips to have been compiled with highway support. * * Improves the performance of

* Access to pixel-derived image statistics for every channel in the image. * A `Promise` is returned when `callback` is not provided. * * - `channe

* Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0. * @param {number} [threshold=128] -

* Use these TIFF options for output image. * * The `density` can be set in pixels/inch via {@link #withmetadata withMetadata} * instead of providin