Sharp

https://sharp.pixelplumbing.com/
Admin
Sharp is a high-performance Node.js library for converting large images into smaller, web-friendly...
Tokens:96,829
Snippets:963
Trust Score:7.8
Update:16 hours ago
Show doc for...
Tokens:
Raw
### Install sharp with bun

Source: https://sharp.pixelplumbing.com/install/

Installs sharp using bun. Ensure your package manager is configured to install optional dependencies.

```bash
bun add sharp
```

--------------------------------

### Install sharp with deno

Source: https://sharp.pixelplumbing.com/install/

Installs sharp using deno. The second command runs a script with the necessary permissions for sharp.

```bash
deno add --quiet npm:sharp
deno run --allow-env --allow-ffi --allow-read --allow-sys ...
```

--------------------------------

### Install sharp with yarn

Source: https://sharp.pixelplumbing.com/install/

Installs sharp using yarn. Ensure your package manager is configured to install optional dependencies.

```bash
yarn add sharp
```

--------------------------------

### Install sharp with npm

Source: https://sharp.pixelplumbing.com/

Install the sharp module using npm. This is the standard installation command for adding sharp to a Node.js project.

```bash
npm install sharp
```

--------------------------------

### Install node-addon-api and node-gyp for sharp build

Source: https://sharp.pixelplumbing.com/install/

If node-addon-api or node-gyp cannot be found during the build, install them with this npm command. These are required dependencies for building sharp from source.

```bash
npm install --save node-addon-api node-gyp
```

--------------------------------

### Install sharp with pnpm

Source: https://sharp.pixelplumbing.com/install/

Installs sharp using pnpm. Ensure your package manager is configured to install optional dependencies.

```bash
pnpm add sharp
```

--------------------------------

### Build sharp from source

Source: https://sharp.pixelplumbing.com/install/

Run these npm commands to install sharp and build it from source. The build process searches for a globally-installed libvips, which can be controlled with the SHARP_IGNORE_GLOBAL_LIBVIPS or SHARP_FORCE_GLOBAL_LIBVIPS environment variables.

```bash
npm install sharp
npm explore sharp -- npm run build
```

--------------------------------

### Install sharp with WebAssembly support

Source: https://sharp.pixelplumbing.com/install/

Install the optional @img/sharp-wasm32 package for runtime environments that provide multi-threaded Wasm via Workers. Note that web browsers, single-threaded environments, native text rendering, and tile-based output are unsupported.

```bash
npm install sharp @img/sharp-wasm32
```

--------------------------------

### Install sharp for glibc and musl Linux with npm

Source: https://sharp.pixelplumbing.com/install/

Installs sharp for Linux with glibc (e.g. Debian) and musl (e.g. Alpine) using npm's --libc flag. Required when cross-targeting Linux.

```bash
npm install --cpu=x64 --os=linux --libc=glibc sharp
npm install --cpu=x64 --os=linux --libc=musl sharp
```

--------------------------------

### serverless-esbuild serverless.yml configuration for sharp

Source: https://sharp.pixelplumbing.com/install/

For serverless-esbuild, configure platform-specific binaries installation via the serverless.yml file.

```yaml
custom:
  esbuild:
    external:
      - sharp
    packagerOptions:
      scripts:
        - npm install --os=linux --libc=glibc --cpu=x64 sharp
```

--------------------------------

### Install sharp for macOS Intel and ARM64 with npm

Source: https://sharp.pixelplumbing.com/install/

Installs sharp for both macOS Intel x64 and ARM64 CPUs using npm's --cpu and --os flags. This is for cross-platform support with npm v10+.

```bash
npm install --cpu=x64 --os=darwin sharp
npm install --cpu=arm64 --os=darwin sharp
```

--------------------------------

### Convert any input to PNG output using toFormat

Source: https://sharp.pixelplumbing.com/api-output/

Forces output to PNG format. The example converts any input to PNG and returns a buffer.

```javascript
// Convert any input to PNG output
const data = await sharp(input)
  .toFormat('png')
  .toBuffer();
```

--------------------------------

### AVIF output with lossless option

Source: https://sharp.pixelplumbing.com/api-output/

Example of using the `avif` method with the `lossless` option set to `true` for lossless compression.

```javascript
const data = await sharp(input)
  .avif({ lossless: true })
  .toBuffer();
```

--------------------------------

### toColourspace example

Source: https://sharp.pixelplumbing.com/api-colour/

Sets the output colourspace. By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.

```javascript
// Output 16 bits per pixel RGB
await sharp(input)
 .toColourspace('rgb16')
 .toFile('16-bpp.png')
```

--------------------------------

### tint example

Source: https://sharp.pixelplumbing.com/api-colour/

Tints the image using the provided colour. The tint parameter is parsed by the color module. An alpha channel may be present and will be unchanged.

```javascript
const output = await sharp(input)
  .tint({ r: 255, g: 240, b: 16 })
  .toBuffer();
```

--------------------------------

### ensureAlpha example with alpha=0

Source: https://sharp.pixelplumbing.com/api-channel/

Ensures the output image has an alpha channel with a fully-transparent alpha level (0). The result is a 4-channel image buffer.

```javascript
// rgba is a 4 channel image with a fully-transparent alpha channel
const rgba = await sharp(rgb)
  .ensureAlpha(0)
  .toBuffer();
```

--------------------------------

### AVIF output with effort option

Source: https://sharp.pixelplumbing.com/api-output/

Example of using the `avif` method with the `effort` option set to 2. This is used to control CPU effort during compression.

```javascript
const data = await sharp(input)
  .avif({ effort: 2 })
  .toBuffer();
```

--------------------------------

### ensureAlpha example with default alpha

Source: https://sharp.pixelplumbing.com/api-channel/

Ensures the output image has an alpha channel. If missing, adds a fully-opaque alpha channel (default alpha=1). No-op if already has alpha.

```javascript
// rgba.png will be a 4 channel image with a fully-opaque alpha channel
await sharp('rgb.jpg')
  .ensureAlpha()
  .toFile('rgba.png')
```

--------------------------------

### pipelineColourspace example

Source: https://sharp.pixelplumbing.com/api-colour/

Sets the pipeline colourspace. The input image is converted to the provided colourspace at the start of the pipeline, and all operations use this colourspace before converting to the output colourspace. Available since 0.29.0.

```javascript
// Run pipeline in 16 bits per channel RGB while converting final result to 8 bits per channel sRGB.
await sharp(input)
 .pipelineColourspace('rgb16')
 .toColourspace('srgb')
 .toFile('16bpc-pipeline-to-8bpc-output.png')
```

--------------------------------

### sharp(input, options?)

Source: https://sharp.pixelplumbing.com/api-constructor/

Creates a sharp instance from an input source. The input can be a file path, buffer, Uint8Array, or stream. Options include raw input dimensions, animated flag, and creation options for generating images.

```APIDOC
## sharp(input, options?)

### Description
Creates a sharp instance for processing images. The input can be a file path, buffer, Uint8Array, or stream. Options allow specifying raw input dimensions, animated flag, and creation options for generating images.

### Method
Constructor

### Parameters
#### input
- **type**: string | Buffer | Uint8Array | Uint8ClampedArray | Array of inputs | Object
- **Required**: Yes
- **Description**: The source image. Can be a file path, buffer, raw pixel array, or an object with `create` or `text` properties. Can also be an array of inputs for joining.

#### options (optional)
- **type**: Object
- **Required**: No
- **Description**: Options for the sharp instance.

##### options.animated
- **type**: boolean
- **Description**: When true, reads all frames/pages of an animated image (e.g., GIF).

##### options.raw
- **type**: Object
- **Description**: Specifies raw input dimensions and channels when input is a raw pixel array.
  - **width** (number) - Required - Width in pixels.
  - **height** (number) - Required - Height in pixels.
  - **channels** (number) - Required - Number of channels (e.g., 3 for RGB).

##### options.create
- **type**: Object
- **Description**: Creates a new image from scratch.
  - **width** (number) - Required - Width in pixels.
  - **height** (number) - Required - Height in pixels.
  - **channels** (number) - Required - Number of channels (e.g., 4 for RGBA).
  - **background** (Object) - Optional - Background color as `{ r, g, b, alpha }`.
  - **noise** (Object) - Optional - Noise generation options.
    - **type** (string) - Required - Noise type (e.g., 'gaussian').
    - **mean** (number) - Optional - Mean value.
    - **sigma** (number) - Optional - Standard deviation.

##### options.text
- **type**: Object
- **Description**: Creates an image from text.
  - **text** (string) - Required - The text to render.
  - **width** (number) - Optional - Maximum width.
  - **height** (number) - Optional - Maximum height.
  - **font** (string) - Optional - Font name.
  - **rgba** (boolean) - Optional - Whether to output RGBA.
  - **dpi** (number) - Optional - DPI setting.
  - **channels** (number) - Optional - Number of channels.

##### options.join
- **type**: Object
- **Description**: Options for joining multiple input images.
  - **across** (number) - Required - Number of images per row.
  - **shim** (number) - Optional - Gutter size in pixels.
  - **animated** (boolean) - Optional - Whether to create an animated image.

### Examples

#### Resize and save to file
```javascript
sharp('input.jpg')
  .resize(300, 200)
  .toFile('output.jpg', function(err) {
    // output.jpg is a 300 pixels wide and 200 pixels high image
    // containing a scaled and cropped version of input.jpg
  });
```

#### Read from remote URL and pipe to writable stream
```javascript
const { body } = await fetch('https://...');
const readableStream = Readable.fromWeb(body);
const transformer = sharp()
  .resize(300)
  .on('info', ({ height }) => {
    console.log(`Image height is ${height}`);
  });
readableStream.pipe(transformer).pipe(writableStream);
```

#### Web Streams API (Node.js >= 24.15.0)
```javascript
import { Duplex } from 'node:stream';

const { body } = await fetch('https://...');
const transformer = Duplex.toWeb(
  sharp().resize(300),
  { readableType: 'bytes' }
);
body.pipeThrough(transformer).pipeTo(writable);
```

#### Create a blank image
```javascript
sharp({
  create: {
    width: 300,
    height: 200,
    channels: 4,
    background: { r: 255, g: 0, b: 0, alpha: 0.5 }
  }
})
.png()
.toBuffer()
.then( ... );
```

#### Convert animated GIF to animated WebP
```javascript
await sharp('in.gif', { animated: true }).toFile('out.webp');
```

#### Read raw pixel array
```javascript
const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
const image = sharp(input, {
  raw: {
    width: 2,
    height: 1,
    channels: 3
  }
});
await image.toFile('my-two-pixels.png');
```

#### Generate Gaussian noise
```javascript
await sharp({
  create: {
    width: 300,
    height: 200,
    channels: 3,
    noise: {
      type: 'gaussian',
      mean: 128,
      sigma: 30
    }
 }
}).toFile('noise.png');
```

#### Generate image from text
```javascript
await sharp({
  text: {
    text: 'Hello, world!',
    width: 400, // max width
    height: 300 // max height
  }
}).toFile('text_bw.png');
```

#### Generate RGBA image from text with pango markup
```javascript
await sharp({
  text: {
    text: '<span foreground="red">Red!</span><span background="cyan">blue</span>',
    font: 'sans',
    rgba: true,
    dpi: 300
  }
}).toFile('text_rgba.png');
```

#### Join four input images as a 2x2 grid
```javascript
const data = await sharp(
 [image1, image2, image3, image4],
 { join: { across: 2, shim: 4 } }
).toBuffer();
```

#### Generate a two-frame animated image from emoji
```javascript
const images = ['😀', '😛'].map(text => ({
  text: { text, width: 64, height: 64, channels: 4, rgba: true }
}));
await sharp(images, { join: { animated: true } }).toFile('out.gif');
```
```

--------------------------------

### flatten example

Source: https://sharp.pixelplumbing.com/api-operation/

Merges alpha transparency channel with a background color and removes the alpha channel. The example uses an orange background '#F0A703'.

```javascript
await sharp(rgbaInput)
  .flatten({ background: '#F0A703' })
  .toBuffer();
```

--------------------------------

### new Sharp([input], [options])

Source: https://sharp.pixelplumbing.com/api-constructor/

Constructor factory to create an instance of sharp, to which further methods are chained. Accepts image data as a buffer, typed array, file path, or stream, and supports options for fail-on behavior, limits, orientation, animation, raw pixel input, and image creation.

```APIDOC
## new Sharp([input], [options])

### Description
Constructor factory to create an instance of `sharp`, to which further methods are chained. JPEG, PNG, WebP, GIF, AVIF or TIFF format image data can be streamed out from this object. When using Stream based output, derived attributes are available from the `info` event. Non-critical problems encountered during processing are emitted as `warning` events. Implements the `stream.Duplex` class. When loading more than one page/frame of an animated image, these are combined as a vertically-stacked "toilet roll" image where the overall height is the `pageHeight` multiplied by the number of `pages`.

### Method
Constructor

### Endpoint
`new Sharp([input], [options])`

### Parameters
#### Input
- **input** (Buffer | ArrayBuffer | Uint8Array | Uint8ClampedArray | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array | string | Array) - Optional - If present, can be a Buffer / ArrayBuffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image data, or a TypedArray containing raw pixel image data, or a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file. An array of inputs can be provided, and these will be joined together. JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.

#### Options
- **options** (Object) - Optional - If present, is an Object with optional attributes.
- **options.failOn** (string) - Optional, default `'warning'` - When to abort processing of invalid pixel data, one of (in order of sensitivity, least to most): 'none', 'truncated', 'error', 'warning'. Higher levels imply lower levels. Invalid metadata will always abort. Use the default 'warning' level with untrusted input.
- **options.limitInputPixels** (number | boolean) - Optional, default `268402689` - Do not process input images where the number of pixels (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted. An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
- **options.limitInputChannels** (number | boolean) - Optional, default `5` - Do not process input images where the number of channels exceeds this limit. Assumes image metadata can be trusted. An integral Number of channels, zero or false to remove limit, true to use default limit of 5.
- **options.unlimited** (boolean) - Optional, default `false` - Set this to `true` to remove safety features that help prevent memory exhaustion (JPEG, PNG, SVG, HEIF).
- **options.autoOrient** (boolean) - Optional, default `false` - Set this to `true` to rotate/flip the image to match EXIF `Orientation`, if any.
- **options.sequentialRead** (boolean) - Optional, default `true` - Set this to `false` to use random access rather than sequential read. Some operations will do this automatically.
- **options.density** (number) - Optional, default `72` - The DPI at which to render SVG and PDF images, in the range 1 to 100000.
- **options.ignoreIcc** (number) - Optional, default `false` - Should the embedded ICC profile, if any, be ignored.
- **options.pages** (number) - Optional, default `1` - Number of pages to extract for multi-page input (GIF, WebP, TIFF), use -1 for all pages.
- **options.page** (number) - Optional, default `0` - Page number to start extracting from for multi-page input (GIF, WebP, TIFF), zero based.
- **options.animated** (boolean) - Optional, default `false` - Set to `true` to read all frames/pages of an animated image (GIF, WebP, TIFF), equivalent of setting `pages` to `-1`.
- **options.raw** (Object) - Optional - Describes raw pixel input image data. See `raw()` for pixel ordering.
  - **options.raw.width** (number) - Required - Integral number of pixels wide.
  - **options.raw.height** (number) - Required - Integral number of pixels high.
  - **options.raw.channels** (number) - Required - Integral number of channels, between 1 and 4.
  - **options.raw.premultiplied** (boolean) - Optional, default `false` - Specifies that the raw input has already been premultiplied, set to `true` to avoid sharp premultiplying the image.
  - **options.raw.pageHeight** (number) - Optional - The pixel height of each page/frame for animated images, must be an integral factor of `raw.height`.
- **options.create** (Object) - Optional - Describes a new image to be created.
  - **options.create.width** (number) - Required - Integral number of pixels wide.
  - **options.create.height** (number) - Required - Integral number of pixels high.
  - **options.create.channels** (number) - Required - Integral number of channels, either 3 (RGB) or 4 (RGBA).

### Throws
- **Error** - Invalid parameters

### Events
- **info** - Emitted when using stream-based output, providing derived attributes.
- **warning** - Emitted for non-critical problems encountered during processing.

```

--------------------------------

### extractChannel example with named channel

Source: https://sharp.pixelplumbing.com/api-channel/

Extracts a single channel from a multi-channel image. The output colourspace is either b-w (8-bit) or grey16 (16-bit). This example extracts the green channel.

```javascript
// green.jpg is a greyscale image containing the green channel of the input
await sharp(input)
  .extractChannel('green')
  .toFile('green.jpg');
```

--------------------------------

### bandbool example with bitwise AND

Source: https://sharp.pixelplumbing.com/api-channel/

Performs a bitwise boolean operation on all input image channels to produce a single channel output. This example uses sharp.bool.and to compute P = R & G & B for each pixel.

```javascript
sharp('3-channel-rgb-input.png')
  .bandbool(sharp.bool.and)
  .toFile('1-channel-output.png', function (err, info) {
    // The output will be a single channel image where each pixel `P = R & G & B`.
    // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
    // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
  });
```

--------------------------------

### png(options)

Source: https://sharp.pixelplumbing.com/api-output/

Configures PNG output options for the Sharp pipeline. Returns a Sharp instance for chaining. Throws an Error if invalid options are provided.

```APIDOC
## png([options]) ⇒ `Sharp`

### Description
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 per pixel is converted to 8 bits per pixel. Set `palette` to `true` for slower, indexed PNG output. For 16 bits per pixel output, convert to `rgb16` via `toColourspace`.

### Throws
- `Error` Invalid options

### Parameters
#### Options
- **options** (Object) - Optional - Options object
- **options.progressive** (boolean) - Optional - Default: `false` - Use progressive (interlace) scan
- **options.compressionLevel** (number) - Optional - Default: `6` - Zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest)
- **options.adaptiveFiltering** (boolean) - Optional - Default: `false` - Use adaptive row filtering
- **options.palette** (boolean) - Optional - Default: `false` - Quantise to a palette-based image with alpha transparency support
- **options.quality** (number) - Optional - Default: `100` - Use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
- **options.effort** (number) - Optional - Default: `7` - CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true`
- **options.colours** (number) - Optional - Default: `256` - Maximum number of palette entries, sets `palette` to `true`
- **options.colors** (number) - Optional - Default: `256` - Alternative spelling of `options.colours`, sets `palette` to `true`
- **options.dither** (number) - Optional - Default: `1.0` - Level of Floyd-Steinberg error diffusion, sets `palette` to `true`
- **options.force** (boolean) - Optional - Default: `true` - Force PNG output, otherwise attempt to use input format

### Examples

```javascript
// Convert any input to full colour PNG output
const data = await sharp(input)
  .png()
  .toBuffer();
```

```javascript
// Convert any input to indexed PNG output (slower)
const data = await sharp(input)
  .png({ palette: true })
  .toBuffer();
```

```javascript
// Output 16 bits per pixel RGB(A)
const data = await sharp(input)
 .toColourspace('rgb16')
 .png()
 .toBuffer();
```
```

--------------------------------

### extractChannel example with channel index

Source: https://sharp.pixelplumbing.com/api-channel/

Extracts a single channel by zero-indexed channel number. The output is raw pixel data. This example extracts the red channel (index 0) and reads pixel values.

```javascript
// red1 is the red value of the first pixel, red2 the second pixel etc.
const [red1, red2, ...] = await sharp(input)
  .extractChannel(0)
  .raw()
  .toBuffer();
```

--------------------------------

### withGainMap example

Source: https://sharp.pixelplumbing.com/api-output/

Converts the main image to HDR using the input gain map, discarding the original gain map. For JPEG output, generates and attaches a new ISO 21496-1 gain map. JPEG output options other than quality are ignored. Experimental since 0.35.0.

```javascript
const outputWithRegeneratedGainMap = await sharp(inputWithGainMap)
  .withGainMap()
  .toBuffer();
```

--------------------------------

### rotate example: rotate before and after resize

Source: https://sharp.pixelplumbing.com/api-operation/

Shows two sharp pipelines: one rotates 90 degrees then resizes to 16x8 with 'fill' fit, the other resizes first then rotates. The order affects the output because rotation changes dimensions before resize.

```javascript
const rotateThenResize = await sharp(input)
  .rotate(90)
  .resize({ width: 16, height: 8, fit: 'fill' })
  .toBuffer();
const resizeThenRotate = await sharp(input)
  .resize({ width: 16, height: 8, fit: 'fill' })
  .rotate(90)
  .toBuffer();
```

--------------------------------

### Clone with Promises for Multiple Output Files

Source: https://sharp.pixelplumbing.com/api-constructor/

Creates a pipeline that downloads an image, clones it to produce JPEG and WebP outputs at different sizes, and uses Promises to track completion. Requires fetch and Readable.fromWeb.

```javascript
// Create a pipeline that will download an image, resize it and format it to different files
// Using Promises to know when the pipeline is complete

const sharpStream = sharp();

const promises = [];
promises.push(
  sharpStream
    .clone()
    .jpeg({ quality: 100 })
    .toFile("originalFile.jpg")
);
promises.push(
  sharpStream
    .clone()
    .resize({ width: 500 })
    .jpeg({ quality: 80 })
    .toFile("optimized-500.jpg")
);
promises.push(
  sharpStream
    .clone()
    .resize({ width: 500 })
    .webp({ quality: 80 })
    .toFile("optimized-500.webp")
);

const res = await fetch("https://www.example.com/some-file.jpg")
Readable.fromWeb(res.body).pipe(sharpStream);
await Promise.all(promises);
```

--------------------------------

### Run sharp benchmark test with Docker

Source: https://sharp.pixelplumbing.com/performance/

Requires Docker. Clones the sharp repository, changes to the test/bench directory, and runs the benchmark script.

```bash
git clone https://github.com/lovell/sharp.git
cd sharp/test/bench
./run-with-docker.sh
```

--------------------------------

### Get and set concurrency with sharp.concurrency()

Source: https://sharp.pixelplumbing.com/api-utility/

Gets or sets the maximum number of threads libvips uses per image. The default is the number of CPU cores, except on glibc-based Linux without jemalloc where it defaults to 1. A value of 0 resets to the number of CPU cores. The method always returns the current concurrency.

```javascript
const threads = sharp.concurrency(); // 4
sharp.concurrency(2); // 2
sharp.concurrency(0); // 4
```

--------------------------------

### cache([options])

Source: https://sharp.pixelplumbing.com/api-utility/

Gets or sets the limits of libvips' operation cache. Returns cache statistics.

```APIDOC
## cache([options])

### Description
Gets or, when options are provided, sets the limits of _libvips'_ operation cache. Existing entries in the cache will be trimmed after any change in limits. This method always returns cache statistics, useful for determining how much working memory is required for a particular task.

### Method
N/A (function call)

### Endpoint
sharp.cache([options])

### Parameters
#### Optional Parameters
- **options** (Object|boolean) - Optional - Object with the following attributes, or boolean where true uses default cache settings and false removes all caching. Default: `true`.
  - **options.memory** (number) - Optional - Maximum memory in MB to use for this cache. Default: `50`.
  - **options.files** (number) - Optional - Maximum number of files to hold open. Default: `20`.
  - **options.items** (number) - Optional - Maximum number of operations to cache. Default: `100`.

### Request Example
```js
const stats = sharp.cache();
```

```js
sharp.cache( { items: 200 } );
sharp.cache( { files: 0 } );
sharp.cache(false);
```

### Response
#### Success Response
- **Object** - Cache statistics, useful for determining how much working memory is required for a particular task.

#### Response Example
```js
{
  // example structure, actual values depend on current cache state
  "memory": 50,
  "files": 20,
  "items": 100
}
```
```

--------------------------------

### sharp affine() transform example

Source: https://sharp.pixelplumbing.com/api-operation/

Creates a sharp pipeline that applies an affine transform with a white background and the nohalo interpolator, then pipes an input stream to it. The output buffer contains the transformed image, and info provides new dimensions.

```javascript
const pipeline = sharp()
  .affine([[1, 0.3], [0.1, 0.7]], {
     background: 'white',
     interpolator: sharp.interpolators.nohalo
  })
  .toBuffer((err, outputBuffer, info) => {
     // outputBuffer contains the transformed image
     // info.width and info.height contain the new dimensions
  });

inputStream
  .pipe(pipeline);
```

--------------------------------

### keepXmp example

Source: https://sharp.pixelplumbing.com/api-output/

Keeps XMP metadata from the input image in the output image. Available since 0.34.3.

```javascript
const outputWithXmp = await sharp(inputWithXmp)
  .keepXmp()
  .toBuffer();
```

--------------------------------

### Streaming tile() with IIFF layout

Source: https://sharp.pixelplumbing.com/api-output/

Creates a Sharp instance configured for IIFF layout and pipes a readable stream through it to a writable stream, demonstrating streaming tile generation.

```javascript
const iiififier = sharp().tile({ layout: "iiif" });
readableStream
  .pipe(iiififier)
  .pipe(writeableStream);
```

--------------------------------

### removeAlpha example

Source: https://sharp.pixelplumbing.com/api-channel/

Removes the alpha channel from an image. No-op if the image has no alpha channel. The output is a 3-channel image without alpha.

```javascript
sharp('rgba.png')
  .removeAlpha()
  .toFile('rgb.png', function(err, info) {
    // rgb.png is a 3 channel image without an alpha channel
  });
```

--------------------------------

### Resize to half width using metadata

Source: https://sharp.pixelplumbing.com/api-resize/

Uses metadata to get the original width, then resizes to 50% of that width. Uses async/await.

```javascript
const scaleByHalf = await sharp(input)
  .metadata()
  .then(({ width }) => sharp(input)
    .resize(Math.round(width * 0.5))
    .toBuffer()
  );
```

--------------------------------

### Get sharp cache statistics

Source: https://sharp.pixelplumbing.com/api-utility/

Calls sharp.cache() with no arguments to retrieve cache statistics, useful for determining working memory requirements.

```javascript
const stats = sharp.cache();
```

--------------------------------

### gif(options)

Source: https://sharp.pixelplumbing.com/api-output/

Configures GIF output options for the Sharp image processing pipeline. Returns a Sharp instance for chaining. Throws an Error for invalid options.

```APIDOC
## gif([options]) ⇒ `Sharp`

### Description
Use these GIF options for the output image. The first entry in the palette is reserved for transparency. The palette of the input image will be re-used if possible.

### Method
`gif`

### Parameters
#### Options
- **options** (Object) - Optional - Output options
- **options.reuse** (boolean) - Optional - Default: `true` - Re-use existing palette, otherwise generate new (slow)
- **options.progressive** (boolean) - Optional - Default: `false` - Use progressive (interlace) scan
- **options.colours** (number) - Optional - Default: `256` - Maximum number of palette entries, including transparency, between 2 and 256
- **options.colors** (number) - Optional - Default: `256` - Alternative spelling of `options.colours`
- **options.effort** (number) - Optional - Default: `7` - CPU effort, between 1 (fastest) and 10 (slowest)
- **options.dither** (number) - Optional - Default: `1.0` - Level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most)
- **options.interFrameMaxError** (number) - Optional - Default: `0` - Maximum inter-frame error for transparency, between 0 (lossless) and 32
- **options.interPaletteMaxError** (number) - Optional - Default: `3` - Maximum inter-palette error for palette reuse, between 0 and 256
- **options.keepDuplicateFrames** (boolean) - Optional - Default: `false` - Keep duplicate frames in the output instead of combining them
- **options.loop** (number) - Optional - Default: `0` - Number of animation iterations, use 0 for infinite animation
- **options.delay** (number | Array.<number>) - Optional - Delay(s) between animation frames (in milliseconds)
- **options.force** (boolean) - Optional - Default: `true` - Force GIF output, otherwise attempt to use input format

### Throws
- `Error` - Invalid options

### Since
0.30.0

### Examples

#### Convert PNG to GIF
```javascript
await sharp(pngBuffer)
  .gif()
  .toBuffer();
```

#### Convert animated WebP to animated GIF
```javascript
await sharp('animated.webp', { animated: true })
  .toFile('animated.gif');
```

#### Create a 128x128, cropped, non-dithered, animated thumbnail of an animated GIF
```javascript
const out = await sharp('in.gif', { animated: true })
  .resize({ width: 128, height: 128 })
  .gif({ dither: 0 })
  .toBuffer();
```

#### Lossy file size reduction of animated GIF
```javascript
await sharp('in.gif', { animated: true })
  .gif({ interFrameMaxError: 8 })
  .toFile('optim.gif');
```
```
Tokens:
Raw