sharp 0.35.2 → 0.35.3-rc.1

package/dist/colour.cjs

@@ -146,12 +146,16 @@ function _getBackgroundColourOption (value) {
     (is.string(value) && value.length >= 3 && value.length <= 200)
   ) {
     const colour = color(value);
-    return [
-      colour.red(),
-      colour.green(),
-      colour.blue(),
-      Math.round(colour.alpha() * 255)
-    ];
+    const red = colour.red();
+    const green = colour.green();
+    const blue = colour.blue();
+    const alpha = Math.round(colour.alpha() * 255);
+    for (const [channel, component] of [['red', red], ['green', green], ['blue', blue], ['alpha', alpha]]) {
+      if (!is.number(component)) {
+        throw is.invalidParameterError(`background.${channel}`, 'number', component);
+      }
+    }
+    return [red, green, blue, alpha];
   } else {
     throw is.invalidParameterError('background', 'object or string', value);
   }

package/dist/colour.mjs

@@ -146,12 +146,16 @@ function _getBackgroundColourOption (value) {
     (is.string(value) && value.length >= 3 && value.length <= 200)
   ) {
     const colour = color(value);
-    return [
-      colour.red(),
-      colour.green(),
-      colour.blue(),
-      Math.round(colour.alpha() * 255)
-    ];
+    const red = colour.red();
+    const green = colour.green();
+    const blue = colour.blue();
+    const alpha = Math.round(colour.alpha() * 255);
+    for (const [channel, component] of [['red', red], ['green', green], ['blue', blue], ['alpha', alpha]]) {
+      if (!is.number(component)) {
+        throw is.invalidParameterError(`background.${channel}`, 'number', component);
+      }
+    }
+    return [red, green, blue, alpha];
   } else {
     throw is.invalidParameterError('background', 'object or string', value);
   }

package/dist/index.d.cts

@@ -1508,11 +1508,11 @@ declare namespace sharp {
         tile?: boolean | undefined;
         /** Horizontal tile size (optional, default 256) */
         tileWidth?: number | undefined;
-        /** Vertical tile size (optional, default 256) */
+        /** Vertical tile size, valid values are integers in the range 1-32768 (optional, default 256) */
         tileHeight?: number | undefined;
-        /** Horizontal resolution in pixels/mm (optional, default 1.0) */
+        /** Horizontal resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
         xres?: number | undefined;
-        /** Vertical resolution in pixels/mm (optional, default 1.0) */
+        /** Vertical resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
         yres?: number | undefined;
         /** Reduce bitdepth to 1, 2 or 4 bit (optional) */
         bitdepth?: 1 | 2 | 4 | undefined;
@@ -1598,13 +1598,13 @@ declare namespace sharp {
     }
 
     interface Region {
-        /** zero-indexed offset from left edge */
+        /** zero-indexed offset from left edge, an integer between 0 and 100000000 */
         left: number;
-        /** zero-indexed offset from top edge */
+        /** zero-indexed offset from top edge, an integer between 0 and 100000000 */
         top: number;
-        /** dimension of extracted image */
+        /** dimension of extracted image, an integer between 0 and 100000000 */
         width: number;
-        /** dimension of extracted image */
+        /** dimension of extracted image, an integer between 0 and 100000000 */
         height: number;
     }
 
@@ -1620,13 +1620,13 @@ declare namespace sharp {
     type ExtendWith = 'background' | 'copy' | 'repeat' | 'mirror';
 
     interface ExtendOptions {
-        /** single pixel count to top edge (optional, default 0) */
+        /** single pixel count to top edge, valid values are integers in the range 0-10000 (optional, default 0) */
         top?: number | undefined;
-        /** single pixel count to left edge (optional, default 0) */
+        /** single pixel count to left edge, valid values are integers in the range 0-10000 (optional, default 0) */
         left?: number | undefined;
-        /** single pixel count to bottom edge (optional, default 0) */
+        /** single pixel count to bottom edge, valid values are integers in the range 0-10000 (optional, default 0) */
         bottom?: number | undefined;
-        /** single pixel count to right edge (optional, default 0) */
+        /** single pixel count to right edge, valid values are integers in the range 0-10000 (optional, default 0) */
         right?: number | undefined;
         /** background colour, parsed by the color module, defaults to black without transparency. (optional, default {r:0,g:0,b:0,alpha:1}) */
         background?: ColorLike | undefined;
@@ -1641,7 +1641,7 @@ declare namespace sharp {
         threshold?: number | undefined;
         /** Does the input more closely resemble line art (e.g. vector) rather than being photographic? (optional, default false) */
         lineArt?: boolean | undefined;
-        /** Leave a margin around trimmed content, value is in pixels. (optional, default 0) */
+        /** Leave a margin around trimmed content, integral number of pixels between 0 and 10000000. (optional, default 0) */
         margin?: number | undefined;
     }
 
@@ -1669,11 +1669,11 @@ declare namespace sharp {
     }
 
     interface ClaheOptions {
-        /** width of the region */
+        /** width of the region. Valid values are integers in the range 1-65536. */
         width: number;
-        /** height of the region */
+        /** height of the region. Valid values are integers in the range 1-65536. */
         height: number;
-        /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100 (inclusive) (optional, default 3) */
+        /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100. (optional, default 3) */
         maxSlope?: number | undefined;
     }
 
@@ -1783,6 +1783,8 @@ declare namespace sharp {
         channels: Channels;
         /** indicating if premultiplication was used */
         premultiplied: boolean;
+        /** Indicates if the output image has an alpha channel */
+        hasAlpha: boolean;
         /** Only defined when using a crop strategy */
         cropOffsetLeft?: number | undefined;
         /** Only defined when using a crop strategy */

package/dist/index.d.mts

@@ -1502,11 +1502,11 @@ export interface TiffOptions extends OutputOptions {
     tile?: boolean | undefined;
     /** Horizontal tile size (optional, default 256) */
     tileWidth?: number | undefined;
-    /** Vertical tile size (optional, default 256) */
+    /** Vertical tile size, valid values are integers in the range 1-32768 (optional, default 256) */
     tileHeight?: number | undefined;
-    /** Horizontal resolution in pixels/mm (optional, default 1.0) */
+    /** Horizontal resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
     xres?: number | undefined;
-    /** Vertical resolution in pixels/mm (optional, default 1.0) */
+    /** Vertical resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
     yres?: number | undefined;
     /** Reduce bitdepth to 1, 2 or 4 bit (optional) */
     bitdepth?: 1 | 2 | 4 | undefined;
@@ -1592,13 +1592,13 @@ export interface ResizeOptions {
 }
 
 export interface Region {
-    /** zero-indexed offset from left edge */
+    /** zero-indexed offset from left edge, an integer between 0 and 100000000 */
     left: number;
-    /** zero-indexed offset from top edge */
+    /** zero-indexed offset from top edge, an integer between 0 and 100000000 */
     top: number;
-    /** dimension of extracted image */
+    /** dimension of extracted image, an integer between 0 and 100000000 */
     width: number;
-    /** dimension of extracted image */
+    /** dimension of extracted image, an integer between 0 and 100000000 */
     height: number;
 }
 
@@ -1614,13 +1614,13 @@ export interface Noise {
 export type ExtendWith = 'background' | 'copy' | 'repeat' | 'mirror';
 
 export interface ExtendOptions {
-    /** single pixel count to top edge (optional, default 0) */
+    /** single pixel count to top edge, valid values are integers in the range 0-10000 (optional, default 0) */
     top?: number | undefined;
-    /** single pixel count to left edge (optional, default 0) */
+    /** single pixel count to left edge, valid values are integers in the range 0-10000 (optional, default 0) */
     left?: number | undefined;
-    /** single pixel count to bottom edge (optional, default 0) */
+    /** single pixel count to bottom edge, valid values are integers in the range 0-10000 (optional, default 0) */
     bottom?: number | undefined;
-    /** single pixel count to right edge (optional, default 0) */
+    /** single pixel count to right edge, valid values are integers in the range 0-10000 (optional, default 0) */
     right?: number | undefined;
     /** background colour, parsed by the color module, defaults to black without transparency. (optional, default {r:0,g:0,b:0,alpha:1}) */
     background?: ColorLike | undefined;
@@ -1635,7 +1635,7 @@ export interface TrimOptions {
     threshold?: number | undefined;
     /** Does the input more closely resemble line art (e.g. vector) rather than being photographic? (optional, default false) */
     lineArt?: boolean | undefined;
-    /** Leave a margin around trimmed content, value is in pixels. (optional, default 0) */
+    /** Leave a margin around trimmed content, integral number of pixels between 0 and 10000000. (optional, default 0) */
     margin?: number | undefined;
 }
 
@@ -1663,11 +1663,11 @@ export interface Kernel {
 }
 
 export interface ClaheOptions {
-    /** width of the region */
+    /** width of the region. Valid values are integers in the range 1-65536. */
     width: number;
-    /** height of the region */
+    /** height of the region. Valid values are integers in the range 1-65536. */
     height: number;
-    /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100 (inclusive) (optional, default 3) */
+    /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100. (optional, default 3) */
     maxSlope?: number | undefined;
 }
 
@@ -1777,6 +1777,8 @@ export interface OutputInfo {
     channels: Channels;
     /** indicating if premultiplication was used */
     premultiplied: boolean;
+    /** Indicates if the output image has an alpha channel */
+    hasAlpha: boolean;
     /** Only defined when using a crop strategy */
     cropOffsetLeft?: number | undefined;
     /** Only defined when using a crop strategy */

package/dist/input.cjs

@@ -181,8 +181,8 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (is.defined(inputOptions.raw)) {
       if (
         is.object(inputOptions.raw) &&
-        is.integer(inputOptions.raw.width) && inputOptions.raw.width > 0 &&
-        is.integer(inputOptions.raw.height) && inputOptions.raw.height > 0 &&
+        is.integer(inputOptions.raw.width) && is.inRange(inputOptions.raw.width, 1, 100000000) &&
+        is.integer(inputOptions.raw.height) && is.inRange(inputOptions.raw.height, 1, 100000000) &&
         is.integer(inputOptions.raw.channels) && is.inRange(inputOptions.raw.channels, 1, 4)
       ) {
         inputDescriptor.rawWidth = inputOptions.raw.width;
@@ -329,8 +329,8 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (is.defined(inputOptions.create)) {
       if (
         is.object(inputOptions.create) &&
-        is.integer(inputOptions.create.width) && inputOptions.create.width > 0 &&
-        is.integer(inputOptions.create.height) && inputOptions.create.height > 0 &&
+        is.integer(inputOptions.create.width) && is.inRange(inputOptions.create.width, 1, 100000000) &&
+        is.integer(inputOptions.create.height) && is.inRange(inputOptions.create.height, 1, 100000000) &&
         is.integer(inputOptions.create.channels)
       ) {
         inputDescriptor.createWidth = inputOptions.create.width;
@@ -410,17 +410,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.width)) {
-          if (is.integer(inputOptions.text.width) && inputOptions.text.width > 0) {
+          if (is.integer(inputOptions.text.width) && is.inRange(inputOptions.text.width, 1, 1000000)) {
             inputDescriptor.textWidth = inputOptions.text.width;
           } else {
-            throw is.invalidParameterError('text.width', 'positive integer', inputOptions.text.width);
+            throw is.invalidParameterError('text.width', 'integer between 1 and 1000000', inputOptions.text.width);
           }
         }
         if (is.defined(inputOptions.text.height)) {
-          if (is.integer(inputOptions.text.height) && inputOptions.text.height > 0) {
+          if (is.integer(inputOptions.text.height) && is.inRange(inputOptions.text.height, 1, 1000000)) {
             inputDescriptor.textHeight = inputOptions.text.height;
           } else {
-            throw is.invalidParameterError('text.height', 'positive integer', inputOptions.text.height);
+            throw is.invalidParameterError('text.height', 'integer between 1 and 1000000', inputOptions.text.height);
           }
         }
         if (is.defined(inputOptions.text.align)) {

package/dist/input.mjs

@@ -181,8 +181,8 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (is.defined(inputOptions.raw)) {
       if (
         is.object(inputOptions.raw) &&
-        is.integer(inputOptions.raw.width) && inputOptions.raw.width > 0 &&
-        is.integer(inputOptions.raw.height) && inputOptions.raw.height > 0 &&
+        is.integer(inputOptions.raw.width) && is.inRange(inputOptions.raw.width, 1, 100000000) &&
+        is.integer(inputOptions.raw.height) && is.inRange(inputOptions.raw.height, 1, 100000000) &&
         is.integer(inputOptions.raw.channels) && is.inRange(inputOptions.raw.channels, 1, 4)
       ) {
         inputDescriptor.rawWidth = inputOptions.raw.width;
@@ -329,8 +329,8 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
     if (is.defined(inputOptions.create)) {
       if (
         is.object(inputOptions.create) &&
-        is.integer(inputOptions.create.width) && inputOptions.create.width > 0 &&
-        is.integer(inputOptions.create.height) && inputOptions.create.height > 0 &&
+        is.integer(inputOptions.create.width) && is.inRange(inputOptions.create.width, 1, 100000000) &&
+        is.integer(inputOptions.create.height) && is.inRange(inputOptions.create.height, 1, 100000000) &&
         is.integer(inputOptions.create.channels)
       ) {
         inputDescriptor.createWidth = inputOptions.create.width;
@@ -410,17 +410,17 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
           }
         }
         if (is.defined(inputOptions.text.width)) {
-          if (is.integer(inputOptions.text.width) && inputOptions.text.width > 0) {
+          if (is.integer(inputOptions.text.width) && is.inRange(inputOptions.text.width, 1, 1000000)) {
             inputDescriptor.textWidth = inputOptions.text.width;
           } else {
-            throw is.invalidParameterError('text.width', 'positive integer', inputOptions.text.width);
+            throw is.invalidParameterError('text.width', 'integer between 1 and 1000000', inputOptions.text.width);
           }
         }
         if (is.defined(inputOptions.text.height)) {
-          if (is.integer(inputOptions.text.height) && inputOptions.text.height > 0) {
+          if (is.integer(inputOptions.text.height) && is.inRange(inputOptions.text.height, 1, 1000000)) {
             inputDescriptor.textHeight = inputOptions.text.height;
           } else {
-            throw is.invalidParameterError('text.height', 'positive integer', inputOptions.text.height);
+            throw is.invalidParameterError('text.height', 'integer between 1 and 1000000', inputOptions.text.height);
           }
         }
         if (is.defined(inputOptions.text.align)) {

package/dist/is.cjs

@@ -78,7 +78,7 @@ const string = (val) => typeof val === 'string' && val.length > 0;
  * Is this value a real number?
  * @private
  */
-const number = (val) => typeof val === 'number' && !Number.isNaN(val);
+const number = (val) => typeof val === 'number' && Number.isFinite(val);
 
 /**
  * Is this value an integer?

package/dist/is.mjs

@@ -78,7 +78,7 @@ const string = (val) => typeof val === 'string' && val.length > 0;
  * Is this value a real number?
  * @private
  */
-const number = (val) => typeof val === 'number' && !Number.isNaN(val);
+const number = (val) => typeof val === 'number' && Number.isFinite(val);
 
 /**
  * Is this value an integer?

package/dist/operation.cjs

@@ -178,7 +178,13 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = Array.isArray(matrix) ? [].concat(...matrix) : [];
+  const isValidShape = Array.isArray(matrix) && (
+    // 1x4 array of numbers
+    (matrix.length === 4 && matrix.every(is.number)) ||
+    // 2x2 array of arrays of numbers
+    (matrix.length === 2 && matrix.every((row) => Array.isArray(row) && row.length === 2))
+  );
+  const flatMatrix = isValidShape ? matrix.flat() : [];
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -646,23 +652,23 @@ function normalize (options) {
  *   .toBuffer();
  *
  * @param {Object} options
- * @param {number} options.width - Integral width of the search window, in pixels.
- * @param {number} options.height - Integral height of the search window, in pixels.
+ * @param {number} options.width - Integral width of the search window, in pixels, between 1 and 65536.
+ * @param {number} options.height - Integral height of the search window, in pixels, between 1 and 65536.
  * @param {number} [options.maxSlope=3] - Integral level of brightening, between 0 and 100, where 0 disables contrast limiting.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function clahe (options) {
   if (is.plainObject(options)) {
-    if (is.integer(options.width) && options.width > 0) {
+    if (is.integer(options.width) && is.inRange(options.width, 1, 65536)) {
       this.options.claheWidth = options.width;
     } else {
-      throw is.invalidParameterError('width', 'integer greater than zero', options.width);
+      throw is.invalidParameterError('width', 'integer between 1 and 65536', options.width);
     }
-    if (is.integer(options.height) && options.height > 0) {
+    if (is.integer(options.height) && is.inRange(options.height, 1, 65536)) {
       this.options.claheHeight = options.height;
     } else {
-      throw is.invalidParameterError('height', 'integer greater than zero', options.height);
+      throw is.invalidParameterError('height', 'integer between 1 and 65536', options.height);
     }
     if (is.defined(options.maxSlope)) {
       if (is.integer(options.maxSlope) && is.inRange(options.maxSlope, 0, 100)) {
@@ -860,13 +866,14 @@ function recomb (inputMatrix) {
   if (!Array.isArray(inputMatrix)) {
     throw is.invalidParameterError('inputMatrix', 'array', inputMatrix);
   }
-  if (inputMatrix.length !== 3 && inputMatrix.length !== 4) {
-    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', inputMatrix.length);
+  const dimensions = inputMatrix.length;
+  if (dimensions !== 3 && dimensions !== 4) {
+    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', dimensions);
   }
-  const recombMatrix = inputMatrix.flat();
-  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
-    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
+  if (!inputMatrix.every((row) => Array.isArray(row) && row.length === dimensions)) {
+    throw is.invalidParameterError('inputMatrix', `array of ${dimensions} arrays of length ${dimensions}`, inputMatrix);
   }
+  const recombMatrix = inputMatrix.flat();
   if (!recombMatrix.every(is.number)) {
     throw is.invalidParameterError('inputMatrix', 'array of numbers', recombMatrix);
   }

package/dist/operation.mjs

@@ -178,7 +178,13 @@ function flop (flop) {
  * @throws {Error} Invalid parameters
  */
 function affine (matrix, options) {
-  const flatMatrix = Array.isArray(matrix) ? [].concat(...matrix) : [];
+  const isValidShape = Array.isArray(matrix) && (
+    // 1x4 array of numbers
+    (matrix.length === 4 && matrix.every(is.number)) ||
+    // 2x2 array of arrays of numbers
+    (matrix.length === 2 && matrix.every((row) => Array.isArray(row) && row.length === 2))
+  );
+  const flatMatrix = isValidShape ? matrix.flat() : [];
   if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
     this.options.affineMatrix = flatMatrix;
   } else {
@@ -646,23 +652,23 @@ function normalize (options) {
  *   .toBuffer();
  *
  * @param {Object} options
- * @param {number} options.width - Integral width of the search window, in pixels.
- * @param {number} options.height - Integral height of the search window, in pixels.
+ * @param {number} options.width - Integral width of the search window, in pixels, between 1 and 65536.
+ * @param {number} options.height - Integral height of the search window, in pixels, between 1 and 65536.
  * @param {number} [options.maxSlope=3] - Integral level of brightening, between 0 and 100, where 0 disables contrast limiting.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function clahe (options) {
   if (is.plainObject(options)) {
-    if (is.integer(options.width) && options.width > 0) {
+    if (is.integer(options.width) && is.inRange(options.width, 1, 65536)) {
       this.options.claheWidth = options.width;
     } else {
-      throw is.invalidParameterError('width', 'integer greater than zero', options.width);
+      throw is.invalidParameterError('width', 'integer between 1 and 65536', options.width);
     }
-    if (is.integer(options.height) && options.height > 0) {
+    if (is.integer(options.height) && is.inRange(options.height, 1, 65536)) {
       this.options.claheHeight = options.height;
     } else {
-      throw is.invalidParameterError('height', 'integer greater than zero', options.height);
+      throw is.invalidParameterError('height', 'integer between 1 and 65536', options.height);
     }
     if (is.defined(options.maxSlope)) {
       if (is.integer(options.maxSlope) && is.inRange(options.maxSlope, 0, 100)) {
@@ -860,13 +866,14 @@ function recomb (inputMatrix) {
   if (!Array.isArray(inputMatrix)) {
     throw is.invalidParameterError('inputMatrix', 'array', inputMatrix);
   }
-  if (inputMatrix.length !== 3 && inputMatrix.length !== 4) {
-    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', inputMatrix.length);
+  const dimensions = inputMatrix.length;
+  if (dimensions !== 3 && dimensions !== 4) {
+    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', dimensions);
   }
-  const recombMatrix = inputMatrix.flat();
-  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
-    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
+  if (!inputMatrix.every((row) => Array.isArray(row) && row.length === dimensions)) {
+    throw is.invalidParameterError('inputMatrix', `array of ${dimensions} arrays of length ${dimensions}`, inputMatrix);
   }
+  const recombMatrix = inputMatrix.flat();
   if (!recombMatrix.every(is.number)) {
     throw is.invalidParameterError('inputMatrix', 'array of numbers', recombMatrix);
   }

package/dist/output.cjs

@@ -1103,10 +1103,10 @@ function trySetAnimationOptions (source, target) {
  * @param {string} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
  * @param {boolean} [options.pyramid=false] - write an image pyramid
  * @param {boolean} [options.tile=false] - write a tiled tiff
- * @param {number} [options.tileWidth=256] - horizontal tile size
- * @param {number} [options.tileHeight=256] - vertical tile size
- * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
- * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
+ * @param {number} [options.tileWidth=256] - horizontal tile size, valid values are integers in the range 1-32768
+ * @param {number} [options.tileHeight=256] - vertical tile size, valid values are integers in the range 1-32768
+ * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm, valid values are numbers in the range 0.001-1000000
+ * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm, valid values are numbers in the range 0.001-1000000
  * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
  * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit
  * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
@@ -1134,17 +1134,17 @@ function tiff (options) {
       this._setBooleanOption('tiffTile', options.tile);
     }
     if (is.defined(options.tileWidth)) {
-      if (is.integer(options.tileWidth) && options.tileWidth > 0) {
+      if (is.integer(options.tileWidth) && is.inRange(options.tileWidth, 1, 32768)) {
         this.options.tiffTileWidth = options.tileWidth;
       } else {
-        throw is.invalidParameterError('tileWidth', 'integer greater than zero', options.tileWidth);
+        throw is.invalidParameterError('tileWidth', 'integer between 1 and 32768', options.tileWidth);
       }
     }
     if (is.defined(options.tileHeight)) {
-      if (is.integer(options.tileHeight) && options.tileHeight > 0) {
+      if (is.integer(options.tileHeight) && is.inRange(options.tileHeight, 1, 32768)) {
         this.options.tiffTileHeight = options.tileHeight;
       } else {
-        throw is.invalidParameterError('tileHeight', 'integer greater than zero', options.tileHeight);
+        throw is.invalidParameterError('tileHeight', 'integer between 1 and 32768', options.tileHeight);
       }
     }
     // miniswhite
@@ -1157,17 +1157,17 @@ function tiff (options) {
     }
     // resolution
     if (is.defined(options.xres)) {
-      if (is.number(options.xres) && options.xres > 0) {
+      if (is.number(options.xres) && is.inRange(options.xres, 0.001, 1000000)) {
         this.options.tiffXres = options.xres;
       } else {
-        throw is.invalidParameterError('xres', 'number greater than zero', options.xres);
+        throw is.invalidParameterError('xres', 'number between 0.001 and 1000000', options.xres);
       }
     }
     if (is.defined(options.yres)) {
-      if (is.number(options.yres) && options.yres > 0) {
+      if (is.number(options.yres) && is.inRange(options.yres, 0.001, 1000000)) {
         this.options.tiffYres = options.yres;
       } else {
-        throw is.invalidParameterError('yres', 'number greater than zero', options.yres);
+        throw is.invalidParameterError('yres', 'number between 0.001 and 1000000', options.yres);
       }
     }
     // compression

package/dist/output.mjs

@@ -1103,10 +1103,10 @@ function trySetAnimationOptions (source, target) {
  * @param {string} [options.predictor='horizontal'] - compression predictor options: none, horizontal, float
  * @param {boolean} [options.pyramid=false] - write an image pyramid
  * @param {boolean} [options.tile=false] - write a tiled tiff
- * @param {number} [options.tileWidth=256] - horizontal tile size
- * @param {number} [options.tileHeight=256] - vertical tile size
- * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
- * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
+ * @param {number} [options.tileWidth=256] - horizontal tile size, valid values are integers in the range 1-32768
+ * @param {number} [options.tileHeight=256] - vertical tile size, valid values are integers in the range 1-32768
+ * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm, valid values are numbers in the range 0.001-1000000
+ * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm, valid values are numbers in the range 0.001-1000000
  * @param {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
  * @param {number} [options.bitdepth=0] - reduce bitdepth to 1, 2 or 4 bit
  * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
@@ -1134,17 +1134,17 @@ function tiff (options) {
       this._setBooleanOption('tiffTile', options.tile);
     }
     if (is.defined(options.tileWidth)) {
-      if (is.integer(options.tileWidth) && options.tileWidth > 0) {
+      if (is.integer(options.tileWidth) && is.inRange(options.tileWidth, 1, 32768)) {
         this.options.tiffTileWidth = options.tileWidth;
       } else {
-        throw is.invalidParameterError('tileWidth', 'integer greater than zero', options.tileWidth);
+        throw is.invalidParameterError('tileWidth', 'integer between 1 and 32768', options.tileWidth);
       }
     }
     if (is.defined(options.tileHeight)) {
-      if (is.integer(options.tileHeight) && options.tileHeight > 0) {
+      if (is.integer(options.tileHeight) && is.inRange(options.tileHeight, 1, 32768)) {
         this.options.tiffTileHeight = options.tileHeight;
       } else {
-        throw is.invalidParameterError('tileHeight', 'integer greater than zero', options.tileHeight);
+        throw is.invalidParameterError('tileHeight', 'integer between 1 and 32768', options.tileHeight);
       }
     }
     // miniswhite
@@ -1157,17 +1157,17 @@ function tiff (options) {
     }
     // resolution
     if (is.defined(options.xres)) {
-      if (is.number(options.xres) && options.xres > 0) {
+      if (is.number(options.xres) && is.inRange(options.xres, 0.001, 1000000)) {
         this.options.tiffXres = options.xres;
       } else {
-        throw is.invalidParameterError('xres', 'number greater than zero', options.xres);
+        throw is.invalidParameterError('xres', 'number between 0.001 and 1000000', options.xres);
       }
     }
     if (is.defined(options.yres)) {
-      if (is.number(options.yres) && options.yres > 0) {
+      if (is.number(options.yres) && is.inRange(options.yres, 0.001, 1000000)) {
         this.options.tiffYres = options.yres;
       } else {
-        throw is.invalidParameterError('yres', 'number greater than zero', options.yres);
+        throw is.invalidParameterError('yres', 'number between 0.001 and 1000000', options.yres);
       }
     }
     // compression

package/dist/resize.cjs

@@ -386,48 +386,52 @@ function resize (widthOrOptions, height, options) {
  *   ...
  *
  * @param {(number|Object)} extend - single pixel count to add to all edges or an Object with per-edge counts
- * @param {number} [extend.top=0]
- * @param {number} [extend.left=0]
- * @param {number} [extend.bottom=0]
- * @param {number} [extend.right=0]
+ * @param {number} [extend.top=0] - number of pixels to add to the top edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.left=0] - number of pixels to add to the left edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.bottom=0] - number of pixels to add to the bottom edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.right=0] - number of pixels to add to the right edge, valid values are integers in the range 0-10000
  * @param {String} [extend.extendWith='background'] - populate new pixels using this method, one of: background, copy, repeat, mirror.
  * @param {String|Object} [extend.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
 */
 function extend (extend) {
-  if (is.integer(extend) && extend > 0) {
-    this.options.extendTop = extend;
-    this.options.extendBottom = extend;
-    this.options.extendLeft = extend;
-    this.options.extendRight = extend;
+  if (is.integer(extend)) {
+    if (is.inRange(extend, 1, 10000)) {
+      this.options.extendTop = extend;
+      this.options.extendBottom = extend;
+      this.options.extendLeft = extend;
+      this.options.extendRight = extend;
+    } else {
+      throw is.invalidParameterError('extend', 'integer between 1 and 10000', extend);
+    }
   } else if (is.object(extend)) {
     if (is.defined(extend.top)) {
-      if (is.integer(extend.top) && extend.top >= 0) {
+      if (is.integer(extend.top) && is.inRange(extend.top, 0, 10000)) {
         this.options.extendTop = extend.top;
       } else {
-        throw is.invalidParameterError('top', 'positive integer', extend.top);
+        throw is.invalidParameterError('top', 'integer between 0 and 10000', extend.top);
       }
     }
     if (is.defined(extend.bottom)) {
-      if (is.integer(extend.bottom) && extend.bottom >= 0) {
+      if (is.integer(extend.bottom) && is.inRange(extend.bottom, 0, 10000)) {
         this.options.extendBottom = extend.bottom;
       } else {
-        throw is.invalidParameterError('bottom', 'positive integer', extend.bottom);
+        throw is.invalidParameterError('bottom', 'integer between 0 and 10000', extend.bottom);
       }
     }
     if (is.defined(extend.left)) {
-      if (is.integer(extend.left) && extend.left >= 0) {
+      if (is.integer(extend.left) && is.inRange(extend.left, 0, 10000)) {
         this.options.extendLeft = extend.left;
       } else {
-        throw is.invalidParameterError('left', 'positive integer', extend.left);
+        throw is.invalidParameterError('left', 'integer between 0 and 10000', extend.left);
       }
     }
     if (is.defined(extend.right)) {
-      if (is.integer(extend.right) && extend.right >= 0) {
+      if (is.integer(extend.right) && is.inRange(extend.right, 0, 10000)) {
         this.options.extendRight = extend.right;
       } else {
-        throw is.invalidParameterError('right', 'positive integer', extend.right);
+        throw is.invalidParameterError('right', 'integer between 0 and 10000', extend.right);
       }
     }
     this._setBackgroundColourOption('extendBackground', extend.background);
@@ -467,10 +471,10 @@ function extend (extend) {
  *   });
  *
  * @param {Object} options - describes the region to extract using integral pixel values
- * @param {number} options.left - zero-indexed offset from left edge
- * @param {number} options.top - zero-indexed offset from top edge
- * @param {number} options.width - width of region to extract
- * @param {number} options.height - height of region to extract
+ * @param {number} options.left - zero-indexed offset from left edge, an integer between 0 and 100000000
+ * @param {number} options.top - zero-indexed offset from top edge, an integer between 0 and 100000000
+ * @param {number} options.width - width of region to extract, an integer between 0 and 100000000
+ * @param {number} options.height - height of region to extract, an integer between 0 and 100000000
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -481,10 +485,10 @@ function extract (options) {
   }
   ['left', 'top', 'width', 'height'].forEach(function (name) {
     const value = options[name];
-    if (is.integer(value) && value >= 0) {
+    if (is.integer(value) && is.inRange(value, 0, 100000000)) {
       this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
     } else {
-      throw is.invalidParameterError(name, 'integer', value);
+      throw is.invalidParameterError(name, 'integer between 0 and 100000000', value);
     }
   }, this);
   // Ensure existing rotation occurs before pre-resize extraction
@@ -554,7 +558,7 @@ function extract (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.
+ * @param {number} [options.margin=0] - Leave a margin around trimmed content, integral number of pixels between 0 and 10000000.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -576,10 +580,10 @@ function trim (options) {
         this._setBooleanOption('trimLineArt', options.lineArt);
       }
       if (is.defined(options.margin)) {
-        if (is.integer(options.margin) && options.margin >= 0) {
+        if (is.integer(options.margin) && is.inRange(options.margin, 0, 10000000)) {
           this.options.trimMargin = options.margin;
         } else {
-          throw is.invalidParameterError('margin', 'positive integer', options.margin);
+          throw is.invalidParameterError('margin', 'integer between 0 and 10000000', options.margin);
         }
       }
     } else {

package/dist/resize.mjs

@@ -386,48 +386,52 @@ function resize (widthOrOptions, height, options) {
  *   ...
  *
  * @param {(number|Object)} extend - single pixel count to add to all edges or an Object with per-edge counts
- * @param {number} [extend.top=0]
- * @param {number} [extend.left=0]
- * @param {number} [extend.bottom=0]
- * @param {number} [extend.right=0]
+ * @param {number} [extend.top=0] - number of pixels to add to the top edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.left=0] - number of pixels to add to the left edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.bottom=0] - number of pixels to add to the bottom edge, valid values are integers in the range 0-10000
+ * @param {number} [extend.right=0] - number of pixels to add to the right edge, valid values are integers in the range 0-10000
  * @param {String} [extend.extendWith='background'] - populate new pixels using this method, one of: background, copy, repeat, mirror.
  * @param {String|Object} [extend.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
 */
 function extend (extend) {
-  if (is.integer(extend) && extend > 0) {
-    this.options.extendTop = extend;
-    this.options.extendBottom = extend;
-    this.options.extendLeft = extend;
-    this.options.extendRight = extend;
+  if (is.integer(extend)) {
+    if (is.inRange(extend, 1, 10000)) {
+      this.options.extendTop = extend;
+      this.options.extendBottom = extend;
+      this.options.extendLeft = extend;
+      this.options.extendRight = extend;
+    } else {
+      throw is.invalidParameterError('extend', 'integer between 1 and 10000', extend);
+    }
   } else if (is.object(extend)) {
     if (is.defined(extend.top)) {
-      if (is.integer(extend.top) && extend.top >= 0) {
+      if (is.integer(extend.top) && is.inRange(extend.top, 0, 10000)) {
         this.options.extendTop = extend.top;
       } else {
-        throw is.invalidParameterError('top', 'positive integer', extend.top);
+        throw is.invalidParameterError('top', 'integer between 0 and 10000', extend.top);
       }
     }
     if (is.defined(extend.bottom)) {
-      if (is.integer(extend.bottom) && extend.bottom >= 0) {
+      if (is.integer(extend.bottom) && is.inRange(extend.bottom, 0, 10000)) {
         this.options.extendBottom = extend.bottom;
       } else {
-        throw is.invalidParameterError('bottom', 'positive integer', extend.bottom);
+        throw is.invalidParameterError('bottom', 'integer between 0 and 10000', extend.bottom);
       }
     }
     if (is.defined(extend.left)) {
-      if (is.integer(extend.left) && extend.left >= 0) {
+      if (is.integer(extend.left) && is.inRange(extend.left, 0, 10000)) {
         this.options.extendLeft = extend.left;
       } else {
-        throw is.invalidParameterError('left', 'positive integer', extend.left);
+        throw is.invalidParameterError('left', 'integer between 0 and 10000', extend.left);
       }
     }
     if (is.defined(extend.right)) {
-      if (is.integer(extend.right) && extend.right >= 0) {
+      if (is.integer(extend.right) && is.inRange(extend.right, 0, 10000)) {
         this.options.extendRight = extend.right;
       } else {
-        throw is.invalidParameterError('right', 'positive integer', extend.right);
+        throw is.invalidParameterError('right', 'integer between 0 and 10000', extend.right);
       }
     }
     this._setBackgroundColourOption('extendBackground', extend.background);
@@ -467,10 +471,10 @@ function extend (extend) {
  *   });
  *
  * @param {Object} options - describes the region to extract using integral pixel values
- * @param {number} options.left - zero-indexed offset from left edge
- * @param {number} options.top - zero-indexed offset from top edge
- * @param {number} options.width - width of region to extract
- * @param {number} options.height - height of region to extract
+ * @param {number} options.left - zero-indexed offset from left edge, an integer between 0 and 100000000
+ * @param {number} options.top - zero-indexed offset from top edge, an integer between 0 and 100000000
+ * @param {number} options.width - width of region to extract, an integer between 0 and 100000000
+ * @param {number} options.height - height of region to extract, an integer between 0 and 100000000
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -481,10 +485,10 @@ function extract (options) {
   }
   ['left', 'top', 'width', 'height'].forEach(function (name) {
     const value = options[name];
-    if (is.integer(value) && value >= 0) {
+    if (is.integer(value) && is.inRange(value, 0, 100000000)) {
       this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
     } else {
-      throw is.invalidParameterError(name, 'integer', value);
+      throw is.invalidParameterError(name, 'integer between 0 and 100000000', value);
     }
   }, this);
   // Ensure existing rotation occurs before pre-resize extraction
@@ -554,7 +558,7 @@ function extract (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.
+ * @param {number} [options.margin=0] - Leave a margin around trimmed content, integral number of pixels between 0 and 10000000.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -576,10 +580,10 @@ function trim (options) {
         this._setBooleanOption('trimLineArt', options.lineArt);
       }
       if (is.defined(options.margin)) {
-        if (is.integer(options.margin) && options.margin >= 0) {
+        if (is.integer(options.margin) && is.inRange(options.margin, 0, 10000000)) {
           this.options.trimMargin = options.margin;
         } else {
-          throw is.invalidParameterError('margin', 'positive integer', options.margin);
+          throw is.invalidParameterError('margin', 'integer between 0 and 10000000', options.margin);
         }
       }
     } else {

package/dist/sharp.cjs

@@ -89,6 +89,12 @@ if (!sharp) {
       errors.push(err);
       sharp = null;
     }
+    if (sharp && process.versions.electron && runtimePlatform.startsWith("linux")) {
+      process.emitWarning(
+        "Binaries provided by Electron for use on Linux may be incompatible with sharp - see https://sharp.pixelplumbing.com/install#electron-and-linux",
+        { code: "SharpElectronLinux" }
+      );
+    }
   } catch (err) {
     errors.push(err);
   }

package/dist/sharp.mjs

@@ -89,6 +89,12 @@ if (!sharp) {
       errors.push(err);
       sharp = null;
     }
+    if (sharp && process.versions.electron && runtimePlatform.startsWith("linux")) {
+      process.emitWarning(
+        "Binaries provided by Electron for use on Linux may be incompatible with sharp - see https://sharp.pixelplumbing.com/install#electron-and-linux",
+        { code: "SharpElectronLinux" }
+      );
+    }
   } catch (err) {
     errors.push(err);
   }

package/dist/utility.cjs

@@ -114,6 +114,12 @@ function cache (options) {
       return sharp.cache(0, 0, 0);
     }
   } else if (is.object(options)) {
+    for (const property of ['memory', 'files', 'items']) {
+      const value = options[property];
+      if (is.defined(value) && !(is.integer(value) && value >= 0)) {
+        throw is.invalidParameterError(property, 'a positive integer', value);
+      }
+    }
     return sharp.cache(options.memory, options.files, options.items);
   } else {
     return sharp.cache();
@@ -155,7 +161,7 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* node:coverage ignore next 7 */
-if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (!process.env.MALLOC_ARENA_MAX && detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 } else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {

package/dist/utility.mjs

@@ -114,6 +114,12 @@ function cache (options) {
       return sharp.cache(0, 0, 0);
     }
   } else if (is.object(options)) {
+    for (const property of ['memory', 'files', 'items']) {
+      const value = options[property];
+      if (is.defined(value) && !(is.integer(value) && value >= 0)) {
+        throw is.invalidParameterError(property, 'a positive integer', value);
+      }
+    }
     return sharp.cache(options.memory, options.files, options.items);
   } else {
     return sharp.cache();
@@ -155,7 +161,7 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* node:coverage ignore next 7 */
-if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (!process.env.MALLOC_ARENA_MAX && detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 } else if (detectLibc.familySync() === detectLibc.MUSL && sharp.concurrency() === 1024) {

package/lib/index.d.ts

@@ -1508,11 +1508,11 @@ declare namespace sharp {
         tile?: boolean | undefined;
         /** Horizontal tile size (optional, default 256) */
         tileWidth?: number | undefined;
-        /** Vertical tile size (optional, default 256) */
+        /** Vertical tile size, valid values are integers in the range 1-32768 (optional, default 256) */
         tileHeight?: number | undefined;
-        /** Horizontal resolution in pixels/mm (optional, default 1.0) */
+        /** Horizontal resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
         xres?: number | undefined;
-        /** Vertical resolution in pixels/mm (optional, default 1.0) */
+        /** Vertical resolution in pixels/mm, valid values are numbers in the range 0.001-1000000 (optional, default 1.0) */
         yres?: number | undefined;
         /** Reduce bitdepth to 1, 2 or 4 bit (optional) */
         bitdepth?: 1 | 2 | 4 | undefined;
@@ -1598,13 +1598,13 @@ declare namespace sharp {
     }
 
     interface Region {
-        /** zero-indexed offset from left edge */
+        /** zero-indexed offset from left edge, an integer between 0 and 100000000 */
         left: number;
-        /** zero-indexed offset from top edge */
+        /** zero-indexed offset from top edge, an integer between 0 and 100000000 */
         top: number;
-        /** dimension of extracted image */
+        /** dimension of extracted image, an integer between 0 and 100000000 */
         width: number;
-        /** dimension of extracted image */
+        /** dimension of extracted image, an integer between 0 and 100000000 */
         height: number;
     }
 
@@ -1620,13 +1620,13 @@ declare namespace sharp {
     type ExtendWith = 'background' | 'copy' | 'repeat' | 'mirror';
 
     interface ExtendOptions {
-        /** single pixel count to top edge (optional, default 0) */
+        /** single pixel count to top edge, valid values are integers in the range 0-10000 (optional, default 0) */
         top?: number | undefined;
-        /** single pixel count to left edge (optional, default 0) */
+        /** single pixel count to left edge, valid values are integers in the range 0-10000 (optional, default 0) */
         left?: number | undefined;
-        /** single pixel count to bottom edge (optional, default 0) */
+        /** single pixel count to bottom edge, valid values are integers in the range 0-10000 (optional, default 0) */
         bottom?: number | undefined;
-        /** single pixel count to right edge (optional, default 0) */
+        /** single pixel count to right edge, valid values are integers in the range 0-10000 (optional, default 0) */
         right?: number | undefined;
         /** background colour, parsed by the color module, defaults to black without transparency. (optional, default {r:0,g:0,b:0,alpha:1}) */
         background?: ColorLike | undefined;
@@ -1641,7 +1641,7 @@ declare namespace sharp {
         threshold?: number | undefined;
         /** Does the input more closely resemble line art (e.g. vector) rather than being photographic? (optional, default false) */
         lineArt?: boolean | undefined;
-        /** Leave a margin around trimmed content, value is in pixels. (optional, default 0) */
+        /** Leave a margin around trimmed content, integral number of pixels between 0 and 10000000. (optional, default 0) */
         margin?: number | undefined;
     }
 
@@ -1669,11 +1669,11 @@ declare namespace sharp {
     }
 
     interface ClaheOptions {
-        /** width of the region */
+        /** width of the region. Valid values are integers in the range 1-65536. */
         width: number;
-        /** height of the region */
+        /** height of the region. Valid values are integers in the range 1-65536. */
         height: number;
-        /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100 (inclusive) (optional, default 3) */
+        /** max slope of the cumulative contrast. A value of 0 disables contrast limiting. Valid values are integers in the range 0-100. (optional, default 3) */
         maxSlope?: number | undefined;
     }
 
@@ -1783,6 +1783,8 @@ declare namespace sharp {
         channels: Channels;
         /** indicating if premultiplication was used */
         premultiplied: boolean;
+        /** Indicates if the output image has an alpha channel */
+        hasAlpha: boolean;
         /** Only defined when using a crop strategy */
         cropOffsetLeft?: number | undefined;
         /** Only defined when using a crop strategy */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.35.2",
+  "version": "0.35.3-rc.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",
   "contributors": [
@@ -160,44 +160,44 @@
   "dependencies": {
     "@img/colour": "^1.1.0",
     "detect-libc": "^2.1.2",
-    "semver": "^7.8.4"
+    "semver": "^7.8.5"
   },
   "optionalDependencies": {
-    "@img/sharp-darwin-arm64": "0.35.2",
-    "@img/sharp-darwin-x64": "0.35.2",
-    "@img/sharp-freebsd-wasm32": "0.35.2",
-    "@img/sharp-libvips-darwin-arm64": "1.3.1",
-    "@img/sharp-libvips-darwin-x64": "1.3.1",
-    "@img/sharp-libvips-linux-arm": "1.3.1",
-    "@img/sharp-libvips-linux-arm64": "1.3.1",
-    "@img/sharp-libvips-linux-ppc64": "1.3.1",
-    "@img/sharp-libvips-linux-riscv64": "1.3.1",
-    "@img/sharp-libvips-linux-s390x": "1.3.1",
-    "@img/sharp-libvips-linux-x64": "1.3.1",
-    "@img/sharp-libvips-linuxmusl-arm64": "1.3.1",
-    "@img/sharp-libvips-linuxmusl-x64": "1.3.1",
-    "@img/sharp-linux-arm": "0.35.2",
-    "@img/sharp-linux-arm64": "0.35.2",
-    "@img/sharp-linux-ppc64": "0.35.2",
-    "@img/sharp-linux-riscv64": "0.35.2",
-    "@img/sharp-linux-s390x": "0.35.2",
-    "@img/sharp-linux-x64": "0.35.2",
-    "@img/sharp-linuxmusl-arm64": "0.35.2",
-    "@img/sharp-linuxmusl-x64": "0.35.2",
-    "@img/sharp-webcontainers-wasm32": "0.35.2",
-    "@img/sharp-win32-arm64": "0.35.2",
-    "@img/sharp-win32-ia32": "0.35.2",
-    "@img/sharp-win32-x64": "0.35.2"
+    "@img/sharp-darwin-arm64": "0.35.3-rc.1",
+    "@img/sharp-darwin-x64": "0.35.3-rc.1",
+    "@img/sharp-freebsd-wasm32": "0.35.3-rc.1",
+    "@img/sharp-libvips-darwin-arm64": "1.3.2-rc.0",
+    "@img/sharp-libvips-darwin-x64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-arm": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-arm64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-ppc64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-riscv64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-s390x": "1.3.2-rc.0",
+    "@img/sharp-libvips-linux-x64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linuxmusl-arm64": "1.3.2-rc.0",
+    "@img/sharp-libvips-linuxmusl-x64": "1.3.2-rc.0",
+    "@img/sharp-linux-arm": "0.35.3-rc.1",
+    "@img/sharp-linux-arm64": "0.35.3-rc.1",
+    "@img/sharp-linux-ppc64": "0.35.3-rc.1",
+    "@img/sharp-linux-riscv64": "0.35.3-rc.1",
+    "@img/sharp-linux-s390x": "0.35.3-rc.1",
+    "@img/sharp-linux-x64": "0.35.3-rc.1",
+    "@img/sharp-linuxmusl-arm64": "0.35.3-rc.1",
+    "@img/sharp-linuxmusl-x64": "0.35.3-rc.1",
+    "@img/sharp-webcontainers-wasm32": "0.35.3-rc.1",
+    "@img/sharp-win32-arm64": "0.35.3-rc.1",
+    "@img/sharp-win32-ia32": "0.35.3-rc.1",
+    "@img/sharp-win32-x64": "0.35.3-rc.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.5.0",
+    "@biomejs/biome": "^2.5.1",
     "@cpplint/cli": "^0.1.0",
     "@emnapi/runtime": "^1.11.1",
-    "@img/sharp-libvips-dev": "1.3.1",
-    "@img/sharp-libvips-dev-wasm32": "1.3.1",
-    "@img/sharp-libvips-win32-arm64": "1.3.1",
-    "@img/sharp-libvips-win32-ia32": "1.3.1",
-    "@img/sharp-libvips-win32-x64": "1.3.1",
+    "@img/sharp-libvips-dev": "1.3.2-rc.0",
+    "@img/sharp-libvips-dev-wasm32": "1.3.2-rc.0",
+    "@img/sharp-libvips-win32-arm64": "1.3.2-rc.0",
+    "@img/sharp-libvips-win32-ia32": "1.3.2-rc.0",
+    "@img/sharp-libvips-win32-x64": "1.3.2-rc.0",
     "@types/node": "*",
     "emnapi": "^1.11.1",
     "exif-reader": "^2.0.3",

package/src/pipeline.cc

@@ -608,38 +608,25 @@ class PipelineWorker : public Napi::AsyncWorker {
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
         baton->height = (nPages > 1 ? targetPageHeight : image.height()) + baton->extendTop + baton->extendBottom;
 
+        std::vector<double> background;
         if (baton->extendWith == VIPS_EXTEND_BACKGROUND) {
-          std::vector<double> background;
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
-
-          image = sharp::StaySequential(image, nPages > 1);
-          image = nPages > 1
-            ? sharp::EmbedMultiPage(image,
-                baton->extendLeft, baton->extendTop, baton->width, baton->height,
-                baton->extendWith, background, nPages, &targetPageHeight)
-            : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
-                VImage::option()->set("extend", baton->extendWith)->set("background", background));
-          if (baton->keepGainMap) {
-            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
-              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
-                ->set("extend", baton->extendWith)
-                ->set("background", 0));
-          }
-        } else {
-          std::vector<double> ignoredBackground(1);
-          image = sharp::StaySequential(image);
-          image = nPages > 1
-            ? sharp::EmbedMultiPage(image,
-                baton->extendLeft, baton->extendTop, baton->width, baton->height,
-                baton->extendWith, ignoredBackground, nPages, &targetPageHeight)
-            : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
-                VImage::option()->set("extend", baton->extendWith));
-          if (baton->keepGainMap) {
-            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
-              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
-                ->set("extend", baton->extendWith)
-                ->set("background", 0));
-          }
+        }
+        image = sharp::StaySequential(image, nPages > 1 || baton->extendWith != VIPS_EXTEND_BACKGROUND);
+        auto options = VImage::option()->set("extend", baton->extendWith);
+        if (baton->extendWith == VIPS_EXTEND_BACKGROUND) {
+          options->set("background", background);
+        }
+        image = nPages > 1
+          ? sharp::EmbedMultiPage(image,
+              baton->extendLeft, baton->extendTop, baton->width, baton->height,
+              baton->extendWith, background, nPages, &targetPageHeight)
+          : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height, options);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
+            baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
+              ->set("extend", baton->extendWith)
+              ->set("background", 0));
         }
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
@@ -957,6 +944,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         baton->pageHeightOut = image.get_int(VIPS_META_PAGE_HEIGHT);
         baton->pagesOut = image.get_int(VIPS_META_N_PAGES);
       }
+      baton->hasAlphaOut = image.has_alpha();
 
       // Output
       sharp::SetTimeout(image, baton->timeoutSeconds);
@@ -996,6 +984,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else {
             baton->channels = std::min(baton->channels, 3);
           }
+          baton->hasAlphaOut = false;
         } else if (baton->formatOut == "jp2" || (baton->formatOut == "input"
           && inputImageType == sharp::ImageType::JP2)) {
           // Write JP2 to Buffer
@@ -1078,6 +1067,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
             baton->channels = std::min(baton->channels, 3);
+            baton->hasAlphaOut = false;
           }
           // Cast pixel values to float, if required
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
@@ -1137,6 +1127,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "dz";
+          if (baton->tileFormat == "jpeg") {
+            baton->hasAlphaOut = false;
+          }
         } else if (baton->formatOut == "jxl" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::JXL)) {
           // Write JXL to buffer
@@ -1224,6 +1217,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
+          baton->hasAlphaOut = false;
         } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
           (willMatchInput && (inputImageType == sharp::ImageType::JP2))) {
           // Write JP2 to file
@@ -1290,6 +1284,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
             baton->channels = std::min(baton->channels, 3);
+            baton->hasAlphaOut = false;
           }
           // Cast pixel values to float, if required
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
@@ -1350,6 +1345,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           vips::VOption *options = BuildOptionsDZ(baton);
           image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
+          if (baton->tileFormat == "jpeg") {
+            baton->hasAlphaOut = false;
+          }
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
           (willMatchInput && inputImageType == sharp::ImageType::VIPS)) {
           // Write V to file
@@ -1434,6 +1432,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("pageHeight", static_cast<int32_t>(baton->pageHeightOut));
         info.Set("pages", static_cast<int32_t>(baton->pagesOut));
       }
+      info.Set("hasAlpha", baton->hasAlphaOut);
 
       if (baton->bufferOutLength > 0) {
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));

package/src/pipeline.h

@@ -49,6 +49,7 @@ struct PipelineBaton {
   int pageHeightOut;
   int pagesOut;
   bool typedArrayOut;
+  bool hasAlphaOut;
   std::vector<Composite *> composite;
   std::vector<sharp::InputDescriptor *> joinChannelIn;
   int topOffsetPre;
@@ -249,6 +250,7 @@ struct PipelineBaton {
     pageHeightOut(0),
     pagesOut(0),
     typedArrayOut(false),
+    hasAlphaOut(false),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),

package/src/utilities.cc

@@ -23,15 +23,15 @@ Napi::Value cache(const Napi::CallbackInfo& info) {
 
   // Set memory limit
   if (info[size_t(0)].IsNumber()) {
-    vips_cache_set_max_mem(info[size_t(0)].As<Napi::Number>().Int32Value() * 1048576);
+    vips_cache_set_max_mem(static_cast<size_t>(info[size_t(0)].As<Napi::Number>().Uint32Value()) * 1048576);
   }
   // Set file limit
   if (info[size_t(1)].IsNumber()) {
-    vips_cache_set_max_files(info[size_t(1)].As<Napi::Number>().Int32Value());
+    vips_cache_set_max_files(info[size_t(1)].As<Napi::Number>().Uint32Value());
   }
   // Set items limit
   if (info[size_t(2)].IsNumber()) {
-    vips_cache_set_max(info[size_t(2)].As<Napi::Number>().Int32Value());
+    vips_cache_set_max(info[size_t(2)].As<Napi::Number>().Uint32Value());
   }
 
   // Get memory stats