@revizly/sharp 0.35.0-revizly4 → 0.35.0-revizly41

package/dist/composite.mjs

@@ -0,0 +1,213 @@
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
+
+import is from './is.mjs';
+
+/**
+ * Blend modes.
+ * @member
+ * @private
+ */
+const blend = {
+  clear: 'clear',
+  source: 'source',
+  over: 'over',
+  in: 'in',
+  out: 'out',
+  atop: 'atop',
+  dest: 'dest',
+  'dest-over': 'dest-over',
+  'dest-in': 'dest-in',
+  'dest-out': 'dest-out',
+  'dest-atop': 'dest-atop',
+  xor: 'xor',
+  add: 'add',
+  saturate: 'saturate',
+  multiply: 'multiply',
+  screen: 'screen',
+  overlay: 'overlay',
+  darken: 'darken',
+  lighten: 'lighten',
+  'colour-dodge': 'colour-dodge',
+  'color-dodge': 'colour-dodge',
+  'colour-burn': 'colour-burn',
+  'color-burn': 'colour-burn',
+  'hard-light': 'hard-light',
+  'soft-light': 'soft-light',
+  difference: 'difference',
+  exclusion: 'exclusion'
+};
+
+/**
+ * Composite image(s) over the processed (resized, extracted etc.) image.
+ *
+ * The images to composite must be the same size or smaller than the processed image.
+ * If both `top` and `left` options are provided, they take precedence over `gravity`.
+ *
+ * Other operations in the same processing pipeline (e.g. resize, rotate, flip,
+ * flop, extract) will always be applied to the input image before composition.
+ *
+ * The `blend` option can be one of `clear`, `source`, `over`, `in`, `out`, `atop`,
+ * `dest`, `dest-over`, `dest-in`, `dest-out`, `dest-atop`,
+ * `xor`, `add`, `saturate`, `multiply`, `screen`, `overlay`, `darken`, `lighten`,
+ * `colour-dodge`, `color-dodge`, `colour-burn`,`color-burn`,
+ * `hard-light`, `soft-light`, `difference`, `exclusion`.
+ *
+ * More information about blend modes can be found at
+ * https://www.libvips.org/API/current/enum.BlendMode.html
+ * and https://www.cairographics.org/operators/
+ *
+ * @since 0.22.0
+ *
+ * @example
+ * await sharp(background)
+ *   .composite([
+ *     { input: layer1, gravity: 'northwest' },
+ *     { input: layer2, gravity: 'southeast' },
+ *   ])
+ *   .toFile('combined.png');
+ *
+ * @example
+ * const output = await sharp('input.gif', { animated: true })
+ *   .composite([
+ *     { input: 'overlay.png', tile: true, blend: 'saturate' }
+ *   ])
+ *   .toBuffer();
+ *
+ * @example
+ * sharp('input.png')
+ *   .rotate(180)
+ *   .resize(300)
+ *   .flatten( { background: '#ff6600' } )
+ *   .composite([{ input: 'overlay.png', gravity: 'southeast' }])
+ *   .sharpen()
+ *   .withMetadata()
+ *   .webp( { quality: 90 } )
+ *   .toBuffer()
+ *   .then(function(outputBuffer) {
+ *     // outputBuffer contains upside down, 300px wide, alpha channel flattened
+ *     // onto orange background, composited with overlay.png with SE gravity,
+ *     // sharpened, with metadata, 90% quality WebP image data. Phew!
+ *   });
+ *
+ * @param {Object[]} images - Ordered list of images to composite
+ * @param {Buffer|String} [images[].input] - Buffer containing image data, String containing the path to an image file, or Create object (see below)
+ * @param {Object} [images[].input.create] - describes a blank overlay to be created.
+ * @param {Number} [images[].input.create.width]
+ * @param {Number} [images[].input.create.height]
+ * @param {Number} [images[].input.create.channels] - 3-4
+ * @param {String|Object} [images[].input.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [images[].input.text] - describes a new text image to be created.
+ * @param {string} [images[].input.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
+ * @param {string} [images[].input.text.font] - font name to render with.
+ * @param {string} [images[].input.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
+ * @param {number} [images[].input.text.width=0] - integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
+ * @param {number} [images[].input.text.height=0] - integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
+ * @param {string} [images[].input.text.align='left'] - text alignment (`'left'`, `'centre'`, `'center'`, `'right'`).
+ * @param {boolean} [images[].input.text.justify=false] - set this to true to apply justification to the text.
+ * @param {number} [images[].input.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
+ * @param {boolean} [images[].input.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for Pango markup features like `<span foreground="red">Red!</span>`.
+ * @param {number} [images[].input.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
+ * @param {Boolean} [images[].autoOrient=false] - set to true to use EXIF orientation data, if present, to orient the image.
+ * @param {String} [images[].blend='over'] - how to blend this image with the image below.
+ * @param {String} [images[].gravity='centre'] - gravity at which to place the overlay.
+ * @param {Number} [images[].top] - the pixel offset from the top edge.
+ * @param {Number} [images[].left] - the pixel offset from the left edge.
+ * @param {Boolean} [images[].tile=false] - set to true to repeat the overlay image across the entire image with the given `gravity`.
+ * @param {Boolean} [images[].premultiplied=false] - set to true to avoid premultiplying the image below. Equivalent to the `--premultiplied` vips option.
+ * @param {Number} [images[].density=72] - number representing the DPI for vector overlay image.
+ * @param {Object} [images[].raw] - describes overlay when using raw pixel data.
+ * @param {Number} [images[].raw.width]
+ * @param {Number} [images[].raw.height]
+ * @param {Number} [images[].raw.channels]
+ * @param {boolean} [images[].animated=false] - Set to `true` to read all frames/pages of an animated image.
+ * @param {string} [images[].failOn='warning'] - @see {@link /api-constructor/ constructor parameters}
+ * @param {number|boolean} [images[].limitInputPixels=268402689] - @see {@link /api-constructor/ constructor parameters}
+ * @param {number|boolean} [images[].limitInputChannels=5] - @see {@link /api-constructor/ constructor parameters}
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function composite (images) {
+  if (!Array.isArray(images)) {
+    throw is.invalidParameterError('images to composite', 'array', images);
+  }
+  this.options.composite = images.map(image => {
+    if (!is.object(image)) {
+      throw is.invalidParameterError('image to composite', 'object', image);
+    }
+    const inputOptions = this._inputOptionsFromObject(image);
+    const composite = {
+      input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
+      blend: 'over',
+      tile: false,
+      left: 0,
+      top: 0,
+      hasOffset: false,
+      gravity: 0,
+      premultiplied: false
+    };
+    if (is.defined(image.blend)) {
+      if (is.string(blend[image.blend])) {
+        composite.blend = blend[image.blend];
+      } else {
+        throw is.invalidParameterError('blend', 'valid blend name', image.blend);
+      }
+    }
+    if (is.defined(image.tile)) {
+      if (is.bool(image.tile)) {
+        composite.tile = image.tile;
+      } else {
+        throw is.invalidParameterError('tile', 'boolean', image.tile);
+      }
+    }
+    if (is.defined(image.left)) {
+      if (is.integer(image.left)) {
+        composite.left = image.left;
+      } else {
+        throw is.invalidParameterError('left', 'integer', image.left);
+      }
+    }
+    if (is.defined(image.top)) {
+      if (is.integer(image.top)) {
+        composite.top = image.top;
+      } else {
+        throw is.invalidParameterError('top', 'integer', image.top);
+      }
+    }
+    if (is.defined(image.top) !== is.defined(image.left)) {
+      throw new Error('Expected both left and top to be set');
+    } else {
+      composite.hasOffset = is.integer(image.top) && is.integer(image.left);
+    }
+    if (is.defined(image.gravity)) {
+      if (is.integer(image.gravity) && is.inRange(image.gravity, 0, 8)) {
+        composite.gravity = image.gravity;
+      } else if (is.string(image.gravity) && is.integer(this.constructor.gravity[image.gravity])) {
+        composite.gravity = this.constructor.gravity[image.gravity];
+      } else {
+        throw is.invalidParameterError('gravity', 'valid gravity', image.gravity);
+      }
+    }
+    if (is.defined(image.premultiplied)) {
+      if (is.bool(image.premultiplied)) {
+        composite.premultiplied = image.premultiplied;
+      } else {
+        throw is.invalidParameterError('premultiplied', 'boolean', image.premultiplied);
+      }
+    }
+    return composite;
+  });
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with composite-related functions.
+ * @module Sharp
+ * @private
+ */
+export default (Sharp) => {
+  Sharp.prototype.composite = composite;
+  Sharp.blend = blend;
+};

package/{lib/constructor.js → dist/constructor.cjs}

@@ -5,9 +5,9 @@
 
 const util = require('node:util');
 const stream = require('node:stream');
-const is = require('./is');
+const is = require('./is.cjs');
 
-require('./sharp');
+require('./sharp.cjs');
 
 // Use NODE_DEBUG=sharp to enable libvips warnings
 const debuglog = util.debuglog('sharp');
@@ -48,7 +48,7 @@ const queueListener = (queueLength) => {
  * // resize to 300 pixels wide,
  * // emit an 'info' event with calculated dimensions
  * // and finally write image data to writableStream
- * const { body } = fetch('https://...');
+ * const { body } = await fetch('https://...');
  * const readableStream = Readable.fromWeb(body);
  * const transformer = sharp()
  *   .resize(300)
@@ -58,6 +58,17 @@ const queueListener = (queueLength) => {
  * readableStream.pipe(transformer).pipe(writableStream);
  *
  * @example
+ * // Web Streams API, requires Node.js >= 24.15.0
+ * const { Duplex } = require('node:stream');
+ *
+ * const { body } = await fetch('https://...');
+ * const transformer = Duplex.toWeb(
+ *   sharp().resize(300),
+ *   { readableType: 'bytes' }
+ * );
+ * body.pipeThrough(transformer).pipeTo(writable);
+ *
+ * @example
  * // Create a blank 300x200 PNG image of semi-translucent red pixels
  * sharp({
  *   create: {
@@ -146,14 +157,16 @@ const queueListener = (queueLength) => {
  *  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.
  * @param {Object} [options] - if present, is an Object with optional attributes.
- * @param {string} [options.failOn='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.
+ * @param {string} [options.failOn='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.
  * @param {number|boolean} [options.limitInputPixels=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).
+ * @param {number|boolean} [options.limitInputChannels=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.
  * @param {boolean} [options.unlimited=false] - Set this to `true` to remove safety features that help prevent memory exhaustion (JPEG, PNG, SVG, HEIF).
  * @param {boolean} [options.autoOrient=false] - Set this to `true` to rotate/flip the image to match EXIF `Orientation`, if any.
  * @param {boolean} [options.sequentialRead=true] - Set this to `false` to use random access rather than sequential read. Some operations will do this automatically.
- * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
+ * @param {number} [options.density=72] - The DPI at which to render SVG and PDF images, in the range 1 to 100000.
  * @param {number} [options.ignoreIcc=false] - should the embedded ICC profile, if any, be ignored.
  * @param {number} [options.pages=1] - Number of pages to extract for multi-page input (GIF, WebP, TIFF), use -1 for all pages.
  * @param {number} [options.page=0] - Page number to start extracting from for multi-page input (GIF, WebP, TIFF), zero based.
@@ -278,6 +291,7 @@ const Sharp = function (input, options) {
     trimBackground: [],
     trimThreshold: -1,
     trimLineArt: false,
+    trimMargin: 0,
     dilateWidth: 0,
     erodeWidth: 0,
     gamma: 0,
@@ -306,6 +320,7 @@ const Sharp = function (input, options) {
     fileOut: '',
     formatOut: 'input',
     streamOut: false,
+    typedArrayOut: false,
     keepMetadata: 0,
     withMetadataOrientation: -1,
     withMetadataDensity: 0,
@@ -313,6 +328,8 @@ const Sharp = function (input, options) {
     withExif: {},
     withExifMerge: true,
     withXmp: '',
+    keepGainMap: false,
+    withGainMap: false,
     resolveWithObject: false,
     loop: -1,
     delay: [],
@@ -348,6 +365,7 @@ const Sharp = function (input, options) {
     webpEffort: 4,
     webpMinSize: false,
     webpMixed: false,
+    webpExact: false,
     gifBitdepth: 8,
     gifEffort: 7,
     gifDither: 1,
@@ -362,7 +380,7 @@ const Sharp = function (input, options) {
     tiffPredictor: 'horizontal',
     tiffPyramid: false,
     tiffMiniswhite: false,
-    tiffBitdepth: 8,
+    tiffBitdepth: 0,
     tiffTile: false,
     tiffTileHeight: 256,
     tiffTileWidth: 256,
@@ -375,6 +393,8 @@ const Sharp = function (input, options) {
     heifEffort: 4,
     heifChromaSubsampling: '4:4:4',
     heifBitdepth: 8,
+    heifTune: 'auto',
+    heifEncoder: 'auto',
     jxlDistance: 1,
     jxlDecodingTier: 0,
     jxlEffort: 7,
@@ -416,29 +436,33 @@ Object.setPrototypeOf(Sharp, stream.Duplex);
  * This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
  *
  * @example
- * const pipeline = sharp().rotate();
- * pipeline.clone().resize(800, 600).pipe(firstWritableStream);
- * pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
- * readableStream.pipe(pipeline);
  * // firstWritableStream receives auto-rotated, resized readableStream
  * // secondWritableStream receives auto-rotated, extracted region of readableStream
  *
+ * const pipeline = sharp().rotate();
+ * pipeline
+ *   .clone()
+ *   .resize(800, 600)
+ *   .pipe(firstWritableStream);
+ * pipeline
+ *   .clone()
+ *   .extract({ left: 20, top: 20, width: 100, height: 100 })
+ *   .pipe(secondWritableStream);
+ * readableStream.pipe(pipeline);
+ *
  * @example
  * // 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 fs = require("fs");
- * const got = require("got");
- * const sharpStream = sharp({ failOn: 'none' });
  *
- * const promises = [];
+ * const sharpStream = sharp();
  *
+ * const promises = [];
  * promises.push(
  *   sharpStream
  *     .clone()
  *     .jpeg({ quality: 100 })
  *     .toFile("originalFile.jpg")
  * );
- *
  * promises.push(
  *   sharpStream
  *     .clone()
@@ -446,7 +470,6 @@ Object.setPrototypeOf(Sharp, stream.Duplex);
  *     .jpeg({ quality: 80 })
  *     .toFile("optimized-500.jpg")
  * );
- *
  * promises.push(
  *   sharpStream
  *     .clone()
@@ -455,19 +478,9 @@ Object.setPrototypeOf(Sharp, stream.Duplex);
  *     .toFile("optimized-500.webp")
  * );
  *
- * // https://github.com/sindresorhus/got/blob/main/documentation/3-streams.md
- * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
- *
- * Promise.all(promises)
- *   .then(res => { console.log("Done!", res); })
- *   .catch(err => {
- *     console.error("Error processing files, let's clean it up", err);
- *     try {
- *       fs.unlinkSync("originalFile.jpg");
- *       fs.unlinkSync("optimized-500.jpg");
- *       fs.unlinkSync("optimized-500.webp");
- *     } catch (e) {}
- *   });
+ * const res = await fetch("https://www.example.com/some-file.jpg")
+ * Readable.fromWeb(res.body).pipe(sharpStream);
+ * await Promise.all(promises);
  *
  * @returns {Sharp}
  */