@bildit-platform/engine 0.1.5 → 0.1.6

package/dist/esm/node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/re.js

@@ -0,0 +1,252 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __module as re } from '../../../../../../_virtual/re.js';
+import { __require as requireConstants } from './constants.js';
+import { __require as requireDebug } from './debug.js';
+
+var hasRequiredRe;
+
+function requireRe () {
+	if (hasRequiredRe) return re.exports;
+	hasRequiredRe = 1;
+	(function (module, exports) {
+		const {
+		  MAX_SAFE_COMPONENT_LENGTH,
+		  MAX_SAFE_BUILD_LENGTH,
+		  MAX_LENGTH,
+		} = requireConstants();
+		const debug = requireDebug();
+		exports = module.exports = {};
+
+		// The actual regexps go on exports.re
+		const re = exports.re = [];
+		const safeRe = exports.safeRe = [];
+		const src = exports.src = [];
+		const safeSrc = exports.safeSrc = [];
+		const t = exports.t = {};
+		let R = 0;
+
+		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+		// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+		// used internally via the safeRe object since all inputs in this library get
+		// normalized first to trim and collapse all extra whitespace. The original
+		// regexes are exported for userland consumption and lower level usage. A
+		// future breaking change could export the safer regex only with a note that
+		// all input should have extra whitespace removed.
+		const safeRegexReplacements = [
+		  ['\\s', 1],
+		  ['\\d', MAX_LENGTH],
+		  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+		];
+
+		const makeSafeRegex = (value) => {
+		  for (const [token, max] of safeRegexReplacements) {
+		    value = value
+		      .split(`${token}*`).join(`${token}{0,${max}}`)
+		      .split(`${token}+`).join(`${token}{1,${max}}`);
+		  }
+		  return value
+		};
+
+		const createToken = (name, value, isGlobal) => {
+		  const safe = makeSafeRegex(value);
+		  const index = R++;
+		  debug(name, index, value);
+		  t[name] = index;
+		  src[index] = value;
+		  safeSrc[index] = safe;
+		  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+		  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
+		};
+
+		// The following Regular Expressions can be used for tokenizing,
+		// validating, and parsing SemVer version strings.
+
+		// ## Numeric Identifier
+		// A single `0`, or a non-zero digit followed by zero or more digits.
+
+		createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+		createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
+
+		// ## Non-numeric Identifier
+		// Zero or more digits, followed by a letter or hyphen, and then zero or
+		// more letters, digits, or hyphens.
+
+		createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+
+		// ## Main Version
+		// Three dot-separated numeric identifiers.
+
+		createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+		                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+		                   `(${src[t.NUMERICIDENTIFIER]})`);
+
+		createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+		// ## Pre-release Version Identifier
+		// A numeric identifier, or a non-numeric identifier.
+
+		createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+		}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+		createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+		}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+		// ## Pre-release Version
+		// Hyphen, followed by one or more dot-separated pre-release version
+		// identifiers.
+
+		createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+		}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+
+		createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+		}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+
+		// ## Build Metadata Identifier
+		// Any combination of digits, letters, or hyphens.
+
+		createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
+
+		// ## Build Metadata
+		// Plus sign, followed by one or more period-separated build metadata
+		// identifiers.
+
+		createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+		}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+
+		// ## Full Version String
+		// A main version, followed optionally by a pre-release version and
+		// build metadata.
+
+		// Note that the only major, minor, patch, and pre-release sections of
+		// the version string are capturing groups.  The build metadata is not a
+		// capturing group, because it should not ever be used in version
+		// comparison.
+
+		createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+		}${src[t.PRERELEASE]}?${
+		  src[t.BUILD]}?`);
+
+		createToken('FULL', `^${src[t.FULLPLAIN]}$`);
+
+		// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+		// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+		// common in the npm registry.
+		createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+		}${src[t.PRERELEASELOOSE]}?${
+		  src[t.BUILD]}?`);
+
+		createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+
+		createToken('GTLT', '((?:<|>)?=?)');
+
+		// Something like "2.*" or "1.2.x".
+		// Note that "x.x" is a valid xRange identifer, meaning "any version"
+		// Only the first item is strictly required.
+		createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+		createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+
+		createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+		                   `(?:${src[t.PRERELEASE]})?${
+		                     src[t.BUILD]}?` +
+		                   `)?)?`);
+
+		createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+		                        `(?:${src[t.PRERELEASELOOSE]})?${
+		                          src[t.BUILD]}?` +
+		                        `)?)?`);
+
+		createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+		createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+
+		// Coercion.
+		// Extract anything that could conceivably be a part of a valid semver
+		createToken('COERCEPLAIN', `${'(^|[^\\d])' +
+		              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+		createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+		createToken('COERCEFULL', src[t.COERCEPLAIN] +
+		              `(?:${src[t.PRERELEASE]})?` +
+		              `(?:${src[t.BUILD]})?` +
+		              `(?:$|[^\\d])`);
+		createToken('COERCERTL', src[t.COERCE], true);
+		createToken('COERCERTLFULL', src[t.COERCEFULL], true);
+
+		// Tilde ranges.
+		// Meaning is "reasonably at or greater than"
+		createToken('LONETILDE', '(?:~>?)');
+
+		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+		exports.tildeTrimReplace = '$1~';
+
+		createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+		createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+		// Caret ranges.
+		// Meaning is "at least and backwards compatible with"
+		createToken('LONECARET', '(?:\\^)');
+
+		createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+		exports.caretTrimReplace = '$1^';
+
+		createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+		createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+		// A simple gt/lt/eq thing, or just "" to indicate "any version"
+		createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+		createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+
+		// An expression to strip any whitespace between the gtlt and the thing
+		// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+		createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+		}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+		exports.comparatorTrimReplace = '$1$2$3';
+
+		// Something like `1.2.3 - 1.2.4`
+		// Note that these all use the loose form, because they'll be
+		// checked against either the strict or loose comparator form
+		// later.
+		createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+		                   `\\s+-\\s+` +
+		                   `(${src[t.XRANGEPLAIN]})` +
+		                   `\\s*$`);
+
+		createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+		                        `\\s+-\\s+` +
+		                        `(${src[t.XRANGEPLAINLOOSE]})` +
+		                        `\\s*$`);
+
+		// Star ranges basically just allow anything at all.
+		createToken('STAR', '(<|>)?=?\\s*\\*');
+		// >=0.0.0 is like a star
+		createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+		createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$'); 
+	} (re, re.exports));
+	return re.exports;
+}
+
+export { requireRe as __require };

package/dist/esm/node_modules/.pnpm/sharp@0.34.1/node_modules/sharp/lib/channel.js

@@ -0,0 +1,201 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __require as requireIs } from './is.js';
+
+var channel;
+var hasRequiredChannel;
+
+function requireChannel () {
+	if (hasRequiredChannel) return channel;
+	hasRequiredChannel = 1;
+
+	const is = requireIs();
+
+	/**
+	 * Boolean operations for bandbool.
+	 * @private
+	 */
+	const bool = {
+	  and: 'and',
+	  or: 'or',
+	  eor: 'eor'
+	};
+
+	/**
+	 * Remove alpha channels, if any. This is a no-op if the image does not have an alpha channel.
+	 *
+	 * See also {@link /api-operation#flatten|flatten}.
+	 *
+	 * @example
+	 * sharp('rgba.png')
+	 *   .removeAlpha()
+	 *   .toFile('rgb.png', function(err, info) {
+	 *     // rgb.png is a 3 channel image without an alpha channel
+	 *   });
+	 *
+	 * @returns {Sharp}
+	 */
+	function removeAlpha () {
+	  this.options.removeAlpha = true;
+	  return this;
+	}
+
+	/**
+	 * Ensure the output image has an alpha transparency channel.
+	 * If missing, the added alpha channel will have the specified
+	 * transparency level, defaulting to fully-opaque (1).
+	 * This is a no-op if the image already has an alpha channel.
+	 *
+	 * @since 0.21.2
+	 *
+	 * @example
+	 * // rgba.png will be a 4 channel image with a fully-opaque alpha channel
+	 * await sharp('rgb.jpg')
+	 *   .ensureAlpha()
+	 *   .toFile('rgba.png')
+	 *
+	 * @example
+	 * // rgba is a 4 channel image with a fully-transparent alpha channel
+	 * const rgba = await sharp(rgb)
+	 *   .ensureAlpha(0)
+	 *   .toBuffer();
+	 *
+	 * @param {number} [alpha=1] - alpha transparency level (0=fully-transparent, 1=fully-opaque)
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid alpha transparency level
+	 */
+	function ensureAlpha (alpha) {
+	  if (is.defined(alpha)) {
+	    if (is.number(alpha) && is.inRange(alpha, 0, 1)) {
+	      this.options.ensureAlpha = alpha;
+	    } else {
+	      throw is.invalidParameterError('alpha', 'number between 0 and 1', alpha);
+	    }
+	  } else {
+	    this.options.ensureAlpha = 1;
+	  }
+	  return this;
+	}
+
+	/**
+	 * Extract a single channel from a multi-channel image.
+	 *
+	 * @example
+	 * // green.jpg is a greyscale image containing the green channel of the input
+	 * await sharp(input)
+	 *   .extractChannel('green')
+	 *   .toFile('green.jpg');
+	 *
+	 * @example
+	 * // red1 is the red value of the first pixel, red2 the second pixel etc.
+	 * const [red1, red2, ...] = await sharp(input)
+	 *   .extractChannel(0)
+	 *   .raw()
+	 *   .toBuffer();
+	 *
+	 * @param {number|string} channel - zero-indexed channel/band number to extract, or `red`, `green`, `blue` or `alpha`.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid channel
+	 */
+	function extractChannel (channel) {
+	  const channelMap = { red: 0, green: 1, blue: 2, alpha: 3 };
+	  if (Object.keys(channelMap).includes(channel)) {
+	    channel = channelMap[channel];
+	  }
+	  if (is.integer(channel) && is.inRange(channel, 0, 4)) {
+	    this.options.extractChannel = channel;
+	  } else {
+	    throw is.invalidParameterError('channel', 'integer or one of: red, green, blue, alpha', channel);
+	  }
+	  return this;
+	}
+
+	/**
+	 * Join one or more channels to the image.
+	 * The meaning of the added channels depends on the output colourspace, set with `toColourspace()`.
+	 * By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+	 * Channel ordering follows vips convention:
+	 * - sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha.
+	 * - CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha.
+	 *
+	 * Buffers may be any of the image formats supported by sharp.
+	 * For raw pixel input, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor.
+	 *
+	 * @param {Array<string|Buffer>|string|Buffer} images - one or more images (file paths, Buffers).
+	 * @param {Object} options - image options, see `sharp()` constructor.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function joinChannel (images, options) {
+	  if (Array.isArray(images)) {
+	    images.forEach(function (image) {
+	      this.options.joinChannelIn.push(this._createInputDescriptor(image, options));
+	    }, this);
+	  } else {
+	    this.options.joinChannelIn.push(this._createInputDescriptor(images, options));
+	  }
+	  return this;
+	}
+
+	/**
+	 * Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+	 *
+	 * @example
+	 * sharp('3-channel-rgb-input.png')
+	 *   .bandbool(sharp.bool.and)
+	 *   .toFile('1-channel-output.png', function (err, info) {
+	 *     // The output will be a single channel image where each pixel `P = R & G & B`.
+	 *     // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
+	 *     // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+	 *   });
+	 *
+	 * @param {string} boolOp - one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function bandbool (boolOp) {
+	  if (is.string(boolOp) && is.inArray(boolOp, ['and', 'or', 'eor'])) {
+	    this.options.bandBoolOp = boolOp;
+	  } else {
+	    throw is.invalidParameterError('boolOp', 'one of: and, or, eor', boolOp);
+	  }
+	  return this;
+	}
+
+	/**
+	 * Decorate the Sharp prototype with channel-related functions.
+	 * @module Sharp
+	 * @private
+	 */
+	channel = function (Sharp) {
+	  Object.assign(Sharp.prototype, {
+	    // Public instance functions
+	    removeAlpha,
+	    ensureAlpha,
+	    extractChannel,
+	    joinChannel,
+	    bandbool
+	  });
+	  // Class attributes
+	  Sharp.bool = bool;
+	};
+	return channel;
+}
+
+export { requireChannel as __require };

package/dist/esm/node_modules/.pnpm/sharp@0.34.1/node_modules/sharp/lib/colour.js

@@ -0,0 +1,208 @@
+/*
+   * Copyright (c) 2022 BILDIT, INC.
+   *
+   * This file, and the software contained herein, are the exclusive property of BILDIT, INC.
+   * Unauthorized copying, distribution, or modification of this software is strictly prohibited.
+   * All rights reserved.
+   *
+   * This file is licensed under the ENT License ("License"). Use of this file is subject to the
+   * terms and conditions specified in the License. You may obtain a copy of the License at:
+   *
+   *     https://bildit.co/ENTLicense
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+   * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   * DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+   * OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   */
+import { __require as requireColor } from '../../../../color@4.2.3/node_modules/color/index.js';
+import { __require as requireIs } from './is.js';
+
+var colour;
+var hasRequiredColour;
+
+function requireColour () {
+	if (hasRequiredColour) return colour;
+	hasRequiredColour = 1;
+
+	const color = requireColor();
+	const is = requireIs();
+
+	/**
+	 * Colourspaces.
+	 * @private
+	 */
+	const colourspace = {
+	  multiband: 'multiband',
+	  'b-w': 'b-w',
+	  bw: 'b-w',
+	  cmyk: 'cmyk',
+	  srgb: 'srgb'
+	};
+
+	/**
+	 * Tint the image using the provided colour.
+	 * An alpha channel may be present and will be unchanged by the operation.
+	 *
+	 * @example
+	 * const output = await sharp(input)
+	 *   .tint({ r: 255, g: 240, b: 16 })
+	 *   .toBuffer();
+	 *
+	 * @param {string|Object} tint - Parsed by the [color](https://www.npmjs.org/package/color) module.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameter
+	 */
+	function tint (tint) {
+	  this._setBackgroundColourOption('tint', tint);
+	  return this;
+	}
+
+	/**
+	 * Convert to 8-bit greyscale; 256 shades of grey.
+	 * This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
+	 * By default the output image will be web-friendly sRGB and contain three (identical) colour channels.
+	 * This may be overridden by other sharp operations such as `toColourspace('b-w')`,
+	 * which will produce an output image containing one colour channel.
+	 * An alpha channel may be present, and will be unchanged by the operation.
+	 *
+	 * @example
+	 * const output = await sharp(input).greyscale().toBuffer();
+	 *
+	 * @param {Boolean} [greyscale=true]
+	 * @returns {Sharp}
+	 */
+	function greyscale (greyscale) {
+	  this.options.greyscale = is.bool(greyscale) ? greyscale : true;
+	  return this;
+	}
+
+	/**
+	 * Alternative spelling of `greyscale`.
+	 * @param {Boolean} [grayscale=true]
+	 * @returns {Sharp}
+	 */
+	function grayscale (grayscale) {
+	  return this.greyscale(grayscale);
+	}
+
+	/**
+	 * Set the pipeline colourspace.
+	 *
+	 * The input image will be converted to the provided colourspace at the start of the pipeline.
+	 * All operations will use this colourspace before converting to the output colourspace,
+	 * as defined by {@link #tocolourspace|toColourspace}.
+	 *
+	 * @since 0.29.0
+	 *
+	 * @example
+	 * // Run pipeline in 16 bits per channel RGB while converting final result to 8 bits per channel sRGB.
+	 * await sharp(input)
+	 *  .pipelineColourspace('rgb16')
+	 *  .toColourspace('srgb')
+	 *  .toFile('16bpc-pipeline-to-8bpc-output.png')
+	 *
+	 * @param {string} [colourspace] - pipeline colourspace e.g. `rgb16`, `scrgb`, `lab`, `grey16` [...](https://github.com/libvips/libvips/blob/41cff4e9d0838498487a00623462204eb10ee5b8/libvips/iofuncs/enumtypes.c#L774)
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function pipelineColourspace (colourspace) {
+	  if (!is.string(colourspace)) {
+	    throw is.invalidParameterError('colourspace', 'string', colourspace);
+	  }
+	  this.options.colourspacePipeline = colourspace;
+	  return this;
+	}
+
+	/**
+	 * Alternative spelling of `pipelineColourspace`.
+	 * @param {string} [colorspace] - pipeline colorspace.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function pipelineColorspace (colorspace) {
+	  return this.pipelineColourspace(colorspace);
+	}
+
+	/**
+	 * Set the output colourspace.
+	 * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+	 *
+	 * @example
+	 * // Output 16 bits per pixel RGB
+	 * await sharp(input)
+	 *  .toColourspace('rgb16')
+	 *  .toFile('16-bpp.png')
+	 *
+	 * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/3c0bfdf74ce1dc37a6429bed47fa76f16e2cd70a/libvips/iofuncs/enumtypes.c#L777-L794)
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function toColourspace (colourspace) {
+	  if (!is.string(colourspace)) {
+	    throw is.invalidParameterError('colourspace', 'string', colourspace);
+	  }
+	  this.options.colourspace = colourspace;
+	  return this;
+	}
+
+	/**
+	 * Alternative spelling of `toColourspace`.
+	 * @param {string} [colorspace] - output colorspace.
+	 * @returns {Sharp}
+	 * @throws {Error} Invalid parameters
+	 */
+	function toColorspace (colorspace) {
+	  return this.toColourspace(colorspace);
+	}
+
+	/**
+	 * Update a colour attribute of the this.options Object.
+	 * @private
+	 * @param {string} key
+	 * @param {string|Object} value
+	 * @throws {Error} Invalid value
+	 */
+	function _setBackgroundColourOption (key, value) {
+	  if (is.defined(value)) {
+	    if (is.object(value) || is.string(value)) {
+	      const colour = color(value);
+	      this.options[key] = [
+	        colour.red(),
+	        colour.green(),
+	        colour.blue(),
+	        Math.round(colour.alpha() * 255)
+	      ];
+	    } else {
+	      throw is.invalidParameterError('background', 'object or string', value);
+	    }
+	  }
+	}
+
+	/**
+	 * Decorate the Sharp prototype with colour-related functions.
+	 * @module Sharp
+	 * @private
+	 */
+	colour = function (Sharp) {
+	  Object.assign(Sharp.prototype, {
+	    // Public
+	    tint,
+	    greyscale,
+	    grayscale,
+	    pipelineColourspace,
+	    pipelineColorspace,
+	    toColourspace,
+	    toColorspace,
+	    // Private
+	    _setBackgroundColourOption
+	  });
+	  // Class attributes
+	  Sharp.colourspace = colourspace;
+	  Sharp.colorspace = colourspace;
+	};
+	return colour;
+}
+
+export { requireColour as __require };