@revizly/sharp 0.34.1-revizly9 → 0.34.4-revizly1

package/README.md

@@ -1,6 +1,6 @@
 # sharp
 
-<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/public/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
+<img src="https://sharp.pixelplumbing.com/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
 
 The typical use case for this high speed Node-API module
 is to convert large images in common formats to

package/lib/channel.js

@@ -74,6 +74,8 @@ function ensureAlpha (alpha) {
 /**
  * Extract a single channel from a multi-channel image.
  *
+ * The output colourspace will be either `b-w` (8-bit) or `grey16` (16-bit).
+ *
  * @example
  * // green.jpg is a greyscale image containing the green channel of the input
  * await sharp(input)

package/lib/constructor.js

@@ -153,9 +153,6 @@ const debuglog = util.debuglog('sharp');
  * @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.
- * @param {number} [options.subifd=-1] - subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image.
- * @param {number} [options.level=0] - level to extract from a multi-level input (OpenSlide), zero based.
- * @param {string|Object} [options.pdfBackground] - Background colour to use when PDF is partially transparent. Parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha. Requires the use of a globally-installed libvips compiled with support for PDFium, Poppler, ImageMagick or GraphicsMagick.
  * @param {boolean} [options.animated=false] - Set to `true` to read all frames/pages of an animated image (GIF, WebP, TIFF), equivalent of setting `pages` to `-1`.
  * @param {Object} [options.raw] - describes raw pixel input image data. See `raw()` for pixel ordering.
  * @param {number} [options.raw.width] - integral number of pixels wide.
@@ -163,15 +160,17 @@ const debuglog = util.debuglog('sharp');
  * @param {number} [options.raw.channels] - integral number of channels, between 1 and 4.
  * @param {boolean} [options.raw.premultiplied] - specifies that the raw input has already been premultiplied, set to `true`
  *  to avoid sharp premultiplying the image. (optional, default `false`)
+ * @param {number} [options.raw.pageHeight] - The pixel height of each page/frame for animated images, must be an integral factor of `raw.height`.
  * @param {Object} [options.create] - describes a new image to be created.
  * @param {number} [options.create.width] - integral number of pixels wide.
  * @param {number} [options.create.height] - integral number of pixels high.
  * @param {number} [options.create.channels] - integral number of channels, either 3 (RGB) or 4 (RGBA).
  * @param {string|Object} [options.create.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {number} [options.create.pageHeight] - The pixel height of each page/frame for animated images, must be an integral factor of `create.height`.
  * @param {Object} [options.create.noise] - describes a noise to be created.
  * @param {string} [options.create.noise.type] - type of generated noise, currently only `gaussian` is supported.
- * @param {number} [options.create.noise.mean] - mean of pixels in generated noise.
- * @param {number} [options.create.noise.sigma] - standard deviation of pixels in generated noise.
+ * @param {number} [options.create.noise.mean=128] - Mean value of pixels in the generated noise.
+ * @param {number} [options.create.noise.sigma=30] - Standard deviation of pixel values in the generated noise.
  * @param {Object} [options.text] - describes a new text image to be created.
  * @param {string} [options.text.text] - text to render as a UTF-8 string. It can contain Pango markup, for example `<i>Le</i>Monde`.
  * @param {string} [options.text.font] - font name to render with.
@@ -191,7 +190,17 @@ const debuglog = util.debuglog('sharp');
  * @param {string|Object} [options.join.background] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
  * @param {string} [options.join.halign='left'] - horizontal alignment style for images joined horizontally (`'left'`, `'centre'`, `'center'`, `'right'`).
  * @param {string} [options.join.valign='top'] - vertical alignment style for images joined vertically (`'top'`, `'centre'`, `'center'`, `'bottom'`).
- *
+ * @param {Object} [options.tiff] - Describes TIFF specific options.
+ * @param {number} [options.tiff.subifd=-1] - Sub Image File Directory to extract for OME-TIFF, defaults to main image.
+ * @param {Object} [options.svg] - Describes SVG specific options.
+ * @param {string} [options.svg.stylesheet] - Custom CSS for SVG input, applied with a User Origin during the CSS cascade.
+ * @param {boolean} [options.svg.highBitdepth=false] - Set to `true` to render SVG input at 32-bits per channel (128-bit) instead of 8-bits per channel (32-bit) RGBA.
+ * @param {Object} [options.pdf] - Describes PDF specific options. Requires the use of a globally-installed libvips compiled with support for PDFium, Poppler, ImageMagick or GraphicsMagick.
+ * @param {string|Object} [options.pdf.background] - Background colour to use when PDF is partially transparent. Parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+ * @param {Object} [options.openSlide] - Describes OpenSlide specific options. Requires the use of a globally-installed libvips compiled with support for OpenSlide.
+ * @param {number} [options.openSlide.level=0] - Level to extract from a multi-level input, zero based.
+ * @param {Object} [options.jp2] - Describes JPEG 2000 specific options. Requires the use of a globally-installed libvips compiled with support for OpenJPEG.
+ * @param {boolean} [options.jp2.oneshot=false] - Set to `true` to decode tiled JPEG 2000 images in a single operation, improving compatibility.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -221,7 +230,8 @@ const Sharp = function (input, options) {
     angle: 0,
     rotationAngle: 0,
     rotationBackground: [0, 0, 0, 255],
-    rotateBeforePreExtract: false,
+    rotateBefore: false,
+    orientBefore: false,
     flip: false,
     flop: false,
     extendTop: 0,
@@ -297,6 +307,7 @@ const Sharp = function (input, options) {
     withIccProfile: '',
     withExif: {},
     withExifMerge: true,
+    withXmp: '',
     resolveWithObject: false,
     loop: -1,
     delay: [],
@@ -337,6 +348,7 @@ const Sharp = function (input, options) {
     gifDither: 1,
     gifInterFrameMaxError: 0,
     gifInterPaletteMaxError: 3,
+    gifKeepDuplicateFrames: false,
     gifReuse: true,
     gifProgressive: false,
     tiffQuality: 80,

package/lib/index.d.ts

@@ -419,7 +419,7 @@ declare namespace sharp {
          * @returns {Sharp}
          */
         autoOrient(): Sharp
-  
+
         /**
          * Flip the image about the vertical Y axis. This always occurs after rotation, if any.
          * The use of flip implies the removal of the EXIF Orientation tag, if any.
@@ -730,6 +730,20 @@ declare namespace sharp {
          */
         withIccProfile(icc: string, options?: WithIccProfileOptions): Sharp;
 
+        /**
+         * Keep all XMP metadata from the input image in the output image.
+         * @returns A sharp instance that can be used to chain operations
+         */
+        keepXmp(): Sharp;
+
+        /**
+         * Set XMP metadata in the output image.
+         * @param {string} xmp - String containing XMP metadata to be embedded in the output image.
+         * @returns A sharp instance that can be used to chain operations
+         * @throws {Error} Invalid parameters
+         */
+        withXmp(xmp: string): Sharp;
+
         /**
          * Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
          * The default behaviour, when withMetadata is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
@@ -1003,12 +1017,22 @@ declare namespace sharp {
         pages?: number | undefined;
         /** Page number to start extracting from for multi-page input (GIF, TIFF, PDF), zero based. (optional, default 0) */
         page?: number | undefined;
-        /** subIFD (Sub Image File Directory) to extract for OME-TIFF, defaults to main image. (optional, default -1) */
+        /** TIFF specific input options */
+        tiff?: TiffInputOptions | undefined;
+        /** SVG specific input options */
+        svg?: SvgInputOptions | undefined;
+        /** PDF specific input options */
+        pdf?: PdfInputOptions | undefined;
+        /** OpenSlide specific input options */
+        openSlide?: OpenSlideInputOptions | undefined;
+        /** JPEG 2000 specific input options */
+        jp2?: Jp2InputOptions | undefined;
+        /** Deprecated: use tiff.subifd instead */
         subifd?: number | undefined;
-        /** Level to extract from a multi-level input (OpenSlide), zero based. (optional, default 0) */
-        level?: number | undefined;
-        /** Background colour to use when PDF is partially transparent. Requires the use of a globally-installed libvips compiled with support for PDFium, Poppler, ImageMagick or GraphicsMagick. */
+        /** Deprecated: use pdf.background instead */
         pdfBackground?: Colour | Color | undefined;
+        /** Deprecated: use openSlide.level instead */
+        level?: number | undefined;
         /** Set to `true` to read all frames/pages of an animated image (equivalent of setting `pages` to `-1`). (optional, default false) */
         animated?: boolean | undefined;
         /** Describes raw pixel input image data. See raw() for pixel ordering. */
@@ -1051,6 +1075,8 @@ declare namespace sharp {
     interface CreateRaw extends Raw {
         /** Specifies that the raw input has already been premultiplied, set to true to avoid sharp premultiplying the image. (optional, default false) */
         premultiplied?: boolean | undefined;
+        /** The height of each page/frame for animated images, must be an integral factor of the overall image height. */
+        pageHeight?: number | undefined;
     }
 
     type CreateChannels = 3 | 4;
@@ -1066,6 +1092,9 @@ declare namespace sharp {
         background: Colour | Color;
         /** Describes a noise to be created. */
         noise?: Noise | undefined;
+        /** The height of each page/frame for animated images, must be an integral factor of the overall image height. */
+        pageHeight?: number | undefined;
+
     }
 
     interface CreateText {
@@ -1114,6 +1143,33 @@ declare namespace sharp {
         valign?: VerticalAlignment | undefined;
     }
 
+    interface TiffInputOptions {
+        /** Sub Image File Directory to extract, defaults to main image. Use -1 for all subifds. */
+        subifd?: number | undefined;
+    }
+
+    interface SvgInputOptions {
+        /** Custom CSS for SVG input, applied with a User Origin during the CSS cascade. */
+        stylesheet?: string | undefined;
+        /** Set to `true` to render SVG input at 32-bits per channel (128-bit) instead of 8-bits per channel (32-bit) RGBA. */
+        highBitdepth?: boolean | undefined;
+    }
+
+    interface PdfInputOptions {
+        /** Background colour to use when PDF is partially transparent. Requires the use of a globally-installed libvips compiled with support for PDFium, Poppler, ImageMagick or GraphicsMagick. */
+        background?: Colour | Color | undefined;
+    }
+
+    interface OpenSlideInputOptions {
+        /** Level to extract from a multi-level input, zero based. (optional, default 0) */
+        level?: number | undefined;
+    }
+
+    interface Jp2InputOptions {
+        /** Set to `true` to load JPEG 2000 images using [oneshot mode](https://github.com/libvips/libvips/issues/4205) */
+        oneshot?: boolean | undefined;
+    }
+
     interface ExifDir {
         [k: string]: string;
     }
@@ -1146,13 +1202,13 @@ declare namespace sharp {
         /** Number value of the EXIF Orientation header, if present */
         orientation?: number | undefined;
         /** Name of decoder used to decompress image data e.g. jpeg, png, webp, gif, svg */
-        format?: keyof FormatEnum | undefined;
+        format: keyof FormatEnum;
         /** Total size of image in bytes, for Stream and Buffer input only */
         size?: number | undefined;
         /** Number of pixels wide (EXIF orientation is not taken into consideration) */
-        width?: number | undefined;
+        width: number;
         /** Number of pixels high (EXIF orientation is not taken into consideration) */
-        height?: number | undefined;
+        height: number;
         /** Any changed metadata after the image orientation is applied. */
         autoOrient: {
             /** Number of pixels wide (EXIF orientation is taken into consideration) */
@@ -1161,19 +1217,19 @@ declare namespace sharp {
             height: number;
         };
         /** Name of colour space interpretation */
-        space?: keyof ColourspaceEnum | undefined;
+        space: keyof ColourspaceEnum;
         /** Number of bands e.g. 3 for sRGB, 4 for CMYK */
-        channels?: Channels | undefined;
+        channels: Channels;
         /** Name of pixel depth format e.g. uchar, char, ushort, float ... */
-        depth?: string | undefined;
+        depth: keyof DepthEnum;
         /** Number of pixels per inch (DPI), if present */
         density?: number | undefined;
         /** String containing JPEG chroma subsampling, 4:2:0 or 4:4:4 for RGB, 4:2:0:4 or 4:4:4:4 for CMYK */
         chromaSubsampling?: string | undefined;
         /** Boolean indicating whether the image is interlaced using a progressive scan */
-        isProgressive?: boolean | undefined;
+        isProgressive: boolean;
         /** Boolean indicating whether the image is palette-based (GIF, PNG). */
-        isPalette?: boolean | undefined;
+        isPalette: boolean;
         /** Number of bits per sample for each channel (GIF, PNG). */
         bitsPerSample?: number | undefined;
         /** Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP */
@@ -1187,9 +1243,9 @@ declare namespace sharp {
         /**  Number of the primary page in a HEIF image */
         pagePrimary?: number | undefined;
         /** Boolean indicating the presence of an embedded ICC profile */
-        hasProfile?: boolean | undefined;
+        hasProfile: boolean;
         /** Boolean indicating the presence of an alpha transparency channel */
-        hasAlpha?: boolean | undefined;
+        hasAlpha: boolean;
         /** Buffer containing raw EXIF data, if present */
         exif?: Buffer | undefined;
         /** Buffer containing raw ICC profile data, if present */
@@ -1198,6 +1254,8 @@ declare namespace sharp {
         iptc?: Buffer | undefined;
         /** Buffer containing raw XMP data, if present */
         xmp?: Buffer | undefined;
+        /** String containing XMP data, if valid UTF-8 */
+        xmpAsString?: string | undefined;
         /** Buffer containing raw TIFFTAG_PHOTOSHOP data, if present */
         tifftagPhotoshop?: Buffer | undefined;
         /** The encoder used to compress an HEIF file, `av1` (AVIF) or `hevc` (HEIC) */
@@ -1336,6 +1394,8 @@ declare namespace sharp {
         nearLossless?: boolean | undefined;
         /** Use high quality chroma subsampling (optional, default false) */
         smartSubsample?: boolean | undefined;
+        /** Auto-adjust the deblocking filter, slow but can improve low contrast edges (optional, default false) */
+        smartDeblock?: boolean | undefined;
         /** Level of CPU effort to reduce file size, integer 0-6 (optional, default 4) */
         effort?: number | undefined;
         /** Prevent use of animation key frames to minimise file size (slow) (optional, default false) */
@@ -1388,9 +1448,11 @@ declare namespace sharp {
         /** Level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most) (optional, default 1.0) */
         dither?: number | undefined;
         /** Maximum inter-frame error for transparency, between 0 (lossless) and 32 (optional, default 0) */
-        interFrameMaxError?: number;
+        interFrameMaxError?: number | undefined;
         /** Maximum inter-palette error for palette reuse, between 0 and 256 (optional, default 3) */
-        interPaletteMaxError?: number;
+        interPaletteMaxError?: number | undefined;
+        /** Keep duplicate frames in the output instead of combining them (optional, default false) */
+        keepDuplicateFrames?: boolean | undefined;
     }
 
     interface TiffOptions extends OutputOptions {
@@ -1508,7 +1570,7 @@ declare namespace sharp {
 
     interface Noise {
         /** type of generated noise, currently only gaussian is supported. */
-        type?: 'gaussian' | undefined;
+        type: 'gaussian';
         /** mean of pixels in generated noise. */
         mean?: number | undefined;
         /** standard deviation of pixels in generated noise. */
@@ -1722,9 +1784,12 @@ declare namespace sharp {
     interface KernelEnum {
         nearest: 'nearest';
         cubic: 'cubic';
+        linear: 'linear';
         mitchell: 'mitchell';
         lanczos2: 'lanczos2';
         lanczos3: 'lanczos3';
+        mks2013: 'mks2013';
+        mks2021: 'mks2021';
     }
 
     interface PresetEnum {
@@ -1743,11 +1808,38 @@ declare namespace sharp {
     }
 
     interface ColourspaceEnum {
-        multiband: string;
         'b-w': string;
-        bw: string;
+        cmc: string;
         cmyk: string;
+        fourier: string;
+        grey16: string;
+        histogram: string;
+        hsv: string;
+        lab: string;
+        labq: string;
+        labs: string;
+        lch: string;
+        matrix: string;
+        multiband: string;
+        rgb: string;
+        rgb16: string;
+        scrgb: string;
         srgb: string;
+        xyz: string;
+        yxy: string;
+    }
+
+    interface DepthEnum {
+        char: string;
+        complex: string;
+        double: string;
+        dpcomplex: string;
+        float: string;
+        int: string;
+        short: string;
+        uchar: string;
+        uint: string;
+        ushort: string;
     }
 
     type FailOnOptions = 'none' | 'truncated' | 'error' | 'warning';
@@ -1815,7 +1907,9 @@ declare namespace sharp {
 
     interface FormatEnum {
         avif: AvailableFormatInfo;
+        dcraw: AvailableFormatInfo;
         dz: AvailableFormatInfo;
+        exr: AvailableFormatInfo;
         fits: AvailableFormatInfo;
         gif: AvailableFormatInfo;
         heif: AvailableFormatInfo;
@@ -1829,6 +1923,7 @@ declare namespace sharp {
         pdf: AvailableFormatInfo;
         png: AvailableFormatInfo;
         ppm: AvailableFormatInfo;
+        rad: AvailableFormatInfo;
         raw: AvailableFormatInfo;
         svg: AvailableFormatInfo;
         tiff: AvailableFormatInfo;

package/lib/input.js

@@ -22,14 +22,27 @@ const align = {
   high: 'high'
 };
 
+const inputStreamParameters = [
+  // Limits and error handling
+  'failOn', 'limitInputPixels', 'unlimited',
+  // Format-generic
+  'animated', 'autoOrient', 'density', 'ignoreIcc', 'page', 'pages', 'sequentialRead',
+  // Format-specific
+  'jp2', 'openSlide', 'pdf', 'raw', 'svg', 'tiff',
+  // Deprecated
+  'failOnError', 'openSlideLevel', 'pdfBackground', 'tiffSubifd'
+];
+
 /**
  * Extract input options, if any, from an object.
  * @private
  */
 function _inputOptionsFromObject (obj) {
-  const { raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd, pdfBackground, autoOrient } = obj;
-  return [raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd, pdfBackground, autoOrient].some(is.defined)
-    ? { raw, density, limitInputPixels, ignoreIcc, unlimited, sequentialRead, failOn, failOnError, animated, page, pages, subifd, pdfBackground, autoOrient }
+  const params = inputStreamParameters
+    .filter(p => is.defined(obj[p]))
+    .map(p => ([p, obj[p]]));
+  return params.length
+    ? Object.fromEntries(params)
     : undefined;
 }
 
@@ -172,8 +185,6 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.rawWidth = inputOptions.raw.width;
         inputDescriptor.rawHeight = inputOptions.raw.height;
         inputDescriptor.rawChannels = inputOptions.raw.channels;
-        inputDescriptor.rawPremultiplied = !!inputOptions.raw.premultiplied;
-
         switch (input.constructor) {
           case Uint8Array:
           case Uint8ClampedArray:
@@ -207,6 +218,25 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
       } else {
         throw new Error('Expected width, height and channels for raw pixel input');
       }
+      inputDescriptor.rawPremultiplied = false;
+      if (is.defined(inputOptions.raw.premultiplied)) {
+        if (is.bool(inputOptions.raw.premultiplied)) {
+          inputDescriptor.rawPremultiplied = inputOptions.raw.premultiplied;
+        } else {
+          throw is.invalidParameterError('raw.premultiplied', 'boolean', inputOptions.raw.premultiplied);
+        }
+      }
+      inputDescriptor.rawPageHeight = 0;
+      if (is.defined(inputOptions.raw.pageHeight)) {
+        if (is.integer(inputOptions.raw.pageHeight) && inputOptions.raw.pageHeight > 0 && inputOptions.raw.pageHeight <= inputOptions.raw.height) {
+          if (inputOptions.raw.height % inputOptions.raw.pageHeight !== 0) {
+            throw new Error(`Expected raw.height ${inputOptions.raw.height} to be a multiple of raw.pageHeight ${inputOptions.raw.pageHeight}`);
+          }
+          inputDescriptor.rawPageHeight = inputOptions.raw.pageHeight;
+        } else {
+          throw is.invalidParameterError('raw.pageHeight', 'positive integer', inputOptions.raw.pageHeight);
+        }
+      }
     }
     // Multi-page input (GIF, TIFF, PDF)
     if (is.defined(inputOptions.animated)) {
@@ -230,26 +260,68 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         throw is.invalidParameterError('page', 'integer between 0 and 100000', inputOptions.page);
       }
     }
-    // Multi-level input (OpenSlide)
-    if (is.defined(inputOptions.level)) {
+    // OpenSlide specific options
+    if (is.object(inputOptions.openSlide) && is.defined(inputOptions.openSlide.level)) {
+      if (is.integer(inputOptions.openSlide.level) && is.inRange(inputOptions.openSlide.level, 0, 256)) {
+        inputDescriptor.openSlideLevel = inputOptions.openSlide.level;
+      } else {
+        throw is.invalidParameterError('openSlide.level', 'integer between 0 and 256', inputOptions.openSlide.level);
+      }
+    } else if (is.defined(inputOptions.level)) {
+      // Deprecated
       if (is.integer(inputOptions.level) && is.inRange(inputOptions.level, 0, 256)) {
-        inputDescriptor.level = inputOptions.level;
+        inputDescriptor.openSlideLevel = inputOptions.level;
       } else {
         throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
       }
     }
-    // Sub Image File Directory (TIFF)
-    if (is.defined(inputOptions.subifd)) {
+    // TIFF specific options
+    if (is.object(inputOptions.tiff) && is.defined(inputOptions.tiff.subifd)) {
+      if (is.integer(inputOptions.tiff.subifd) && is.inRange(inputOptions.tiff.subifd, -1, 100000)) {
+        inputDescriptor.tiffSubifd = inputOptions.tiff.subifd;
+      } else {
+        throw is.invalidParameterError('tiff.subifd', 'integer between -1 and 100000', inputOptions.tiff.subifd);
+      }
+    } else if (is.defined(inputOptions.subifd)) {
+      // Deprecated
       if (is.integer(inputOptions.subifd) && is.inRange(inputOptions.subifd, -1, 100000)) {
-        inputDescriptor.subifd = inputOptions.subifd;
+        inputDescriptor.tiffSubifd = inputOptions.subifd;
       } else {
         throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
       }
     }
-    // PDF background colour
-    if (is.defined(inputOptions.pdfBackground)) {
+    // SVG specific options
+    if (is.object(inputOptions.svg)) {
+      if (is.defined(inputOptions.svg.stylesheet)) {
+        if (is.string(inputOptions.svg.stylesheet)) {
+          inputDescriptor.svgStylesheet = inputOptions.svg.stylesheet;
+        } else {
+          throw is.invalidParameterError('svg.stylesheet', 'string', inputOptions.svg.stylesheet);
+        }
+      }
+      if (is.defined(inputOptions.svg.highBitdepth)) {
+        if (is.bool(inputOptions.svg.highBitdepth)) {
+          inputDescriptor.svgHighBitdepth = inputOptions.svg.highBitdepth;
+        } else {
+          throw is.invalidParameterError('svg.highBitdepth', 'boolean', inputOptions.svg.highBitdepth);
+        }
+      }
+    }
+    // PDF specific options
+    if (is.object(inputOptions.pdf) && is.defined(inputOptions.pdf.background)) {
+      inputDescriptor.pdfBackground = this._getBackgroundColourOption(inputOptions.pdf.background);
+    } else if (is.defined(inputOptions.pdfBackground)) {
+      // Deprecated
       inputDescriptor.pdfBackground = this._getBackgroundColourOption(inputOptions.pdfBackground);
     }
+    // JPEG 2000 specific options
+    if (is.object(inputOptions.jp2) && is.defined(inputOptions.jp2.oneshot)) {
+      if (is.bool(inputOptions.jp2.oneshot)) {
+        inputDescriptor.jp2Oneshot = inputOptions.jp2.oneshot;
+      } else {
+        throw is.invalidParameterError('jp2.oneshot', 'boolean', inputOptions.jp2.oneshot);
+      }
+    }
     // Create new image
     if (is.defined(inputOptions.create)) {
       if (
@@ -261,27 +333,44 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
         inputDescriptor.createWidth = inputOptions.create.width;
         inputDescriptor.createHeight = inputOptions.create.height;
         inputDescriptor.createChannels = inputOptions.create.channels;
+        inputDescriptor.createPageHeight = 0;
+        if (is.defined(inputOptions.create.pageHeight)) {
+          if (is.integer(inputOptions.create.pageHeight) && inputOptions.create.pageHeight > 0 && inputOptions.create.pageHeight <= inputOptions.create.height) {
+            if (inputOptions.create.height % inputOptions.create.pageHeight !== 0) {
+              throw new Error(`Expected create.height ${inputOptions.create.height} to be a multiple of create.pageHeight ${inputOptions.create.pageHeight}`);
+            }
+            inputDescriptor.createPageHeight = inputOptions.create.pageHeight;
+          } else {
+            throw is.invalidParameterError('create.pageHeight', 'positive integer', inputOptions.create.pageHeight);
+          }
+        }
         // Noise
         if (is.defined(inputOptions.create.noise)) {
           if (!is.object(inputOptions.create.noise)) {
             throw new Error('Expected noise to be an object');
           }
-          if (!is.inArray(inputOptions.create.noise.type, ['gaussian'])) {
+          if (inputOptions.create.noise.type !== 'gaussian') {
             throw new Error('Only gaussian noise is supported at the moment');
           }
+          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
           if (!is.inRange(inputOptions.create.channels, 1, 4)) {
             throw is.invalidParameterError('create.channels', 'number between 1 and 4', inputOptions.create.channels);
           }
-          inputDescriptor.createNoiseType = inputOptions.create.noise.type;
-          if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
-            inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
-          } else {
-            throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+          inputDescriptor.createNoiseMean = 128;
+          if (is.defined(inputOptions.create.noise.mean)) {
+            if (is.number(inputOptions.create.noise.mean) && is.inRange(inputOptions.create.noise.mean, 0, 10000)) {
+              inputDescriptor.createNoiseMean = inputOptions.create.noise.mean;
+            } else {
+              throw is.invalidParameterError('create.noise.mean', 'number between 0 and 10000', inputOptions.create.noise.mean);
+            }
           }
-          if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
-            inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
-          } else {
-            throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+          inputDescriptor.createNoiseSigma = 30;
+          if (is.defined(inputOptions.create.noise.sigma)) {
+            if (is.number(inputOptions.create.noise.sigma) && is.inRange(inputOptions.create.noise.sigma, 0, 10000)) {
+              inputDescriptor.createNoiseSigma = inputOptions.create.noise.sigma;
+            } else {
+              throw is.invalidParameterError('create.noise.sigma', 'number between 0 and 10000', inputOptions.create.noise.sigma);
+            }
           }
         } else if (is.defined(inputOptions.create.background)) {
           if (!is.inRange(inputOptions.create.channels, 3, 4)) {
@@ -516,6 +605,7 @@ function _isStreamInput () {
  * - `icc`: Buffer containing raw [ICC](https://www.npmjs.com/package/icc) profile data, if present
  * - `iptc`: Buffer containing raw IPTC data, if present
  * - `xmp`: Buffer containing raw XMP data, if present
+ * - `xmpAsString`: String containing XMP data, if valid UTF-8.
  * - `tifftagPhotoshop`: Buffer containing raw TIFFTAG_PHOTOSHOP data, if present
  * - `formatMagick`: String containing format for images loaded via *magick
  * - `comments`: Array of keyword/text pairs representing PNG text blocks, if present.

package/lib/libvips.js

@@ -18,9 +18,9 @@ const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).versio
 
 const prebuiltPlatforms = [
   'darwin-arm64', 'darwin-x64',
-  'linux-arm', 'linux-arm64', 'linux-s390x', 'linux-x64',
+  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-s390x', 'linux-x64',
   'linuxmusl-arm64', 'linuxmusl-x64',
-  'win32-ia32', 'win32-x64'
+  'win32-arm64', 'win32-ia32', 'win32-x64'
 ];
 
 const spawnSyncOptions = {