9remote 0.1.7 → 0.1.9

package/dist/standalone/node_modules/next/node_modules/semver/internal/re.js

@@ -1,223 +0,0 @@
-'use strict'
-
-const {
-  MAX_SAFE_COMPONENT_LENGTH,
-  MAX_SAFE_BUILD_LENGTH,
-  MAX_LENGTH,
-} = require('./constants')
-const debug = require('./debug')
-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.
-// Non-numberic identifiers include numberic identifiers but can be longer.
-// Therefore non-numberic identifiers must go first.
-
-createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
-}|${src[t.NUMERICIDENTIFIER]})`)
-
-createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
-}|${src[t.NUMERICIDENTIFIERLOOSE]})`)
-
-// ## 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*$')

package/dist/standalone/node_modules/next/node_modules/semver/package.json

@@ -1,78 +0,0 @@
-{
-  "name": "semver",
-  "version": "7.7.3",
-  "description": "The semantic version parser used by npm.",
-  "main": "index.js",
-  "scripts": {
-    "test": "tap",
-    "snap": "tap",
-    "lint": "npm run eslint",
-    "postlint": "template-oss-check",
-    "lintfix": "npm run eslint -- --fix",
-    "posttest": "npm run lint",
-    "template-oss-apply": "template-oss-apply --force",
-    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
-  },
-  "devDependencies": {
-    "@npmcli/eslint-config": "^5.0.0",
-    "@npmcli/template-oss": "4.25.1",
-    "benchmark": "^2.1.4",
-    "tap": "^16.0.0"
-  },
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/npm/node-semver.git"
-  },
-  "bin": {
-    "semver": "bin/semver.js"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "classes/",
-    "functions/",
-    "internal/",
-    "ranges/",
-    "index.js",
-    "preload.js",
-    "range.bnf"
-  ],
-  "tap": {
-    "timeout": 30,
-    "coverage-map": "map.js",
-    "nyc-arg": [
-      "--exclude",
-      "tap-snapshots/**"
-    ]
-  },
-  "engines": {
-    "node": ">=10"
-  },
-  "author": "GitHub Inc.",
-  "templateOSS": {
-    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "4.25.1",
-    "engines": ">=10",
-    "distPaths": [
-      "classes/",
-      "functions/",
-      "internal/",
-      "ranges/",
-      "index.js",
-      "preload.js",
-      "range.bnf"
-    ],
-    "allowPaths": [
-      "/classes/",
-      "/functions/",
-      "/internal/",
-      "/ranges/",
-      "/index.js",
-      "/preload.js",
-      "/range.bnf",
-      "/benchmarks"
-    ],
-    "publish": "true"
-  }
-}

package/dist/standalone/node_modules/next/node_modules/sharp/lib/channel.js

@@ -1,177 +0,0 @@
-/*!
-  Copyright 2013 Lovell Fuller and others.
-  SPDX-License-Identifier: Apache-2.0
-*/
-
-const is = require('./is');
-
-/**
- * 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.
- *
- * 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)
- *   .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
- */
-module.exports = (Sharp) => {
-  Object.assign(Sharp.prototype, {
-    // Public instance functions
-    removeAlpha,
-    ensureAlpha,
-    extractChannel,
-    joinChannel,
-    bandbool
-  });
-  // Class attributes
-  Sharp.bool = bool;
-};

package/dist/standalone/node_modules/next/node_modules/sharp/lib/colour.js

@@ -1,195 +0,0 @@
-/*!
-  Copyright 2013 Lovell Fuller and others.
-  SPDX-License-Identifier: Apache-2.0
-*/
-
-const color = require('@img/colour');
-const is = require('./is');
-
-/**
- * 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://www.libvips.org/API/current/enum.Interpretation.html)
- * @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://www.libvips.org/API/current/enum.Interpretation.html)
- * @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);
-}
-
-/**
- * Create a RGBA colour array from a given value.
- * @private
- * @param {string|Object} value
- * @throws {Error} Invalid value
- */
-function _getBackgroundColourOption (value) {
-  if (
-    is.object(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)
-    ];
-  } else {
-    throw is.invalidParameterError('background', 'object or string', value);
-  }
-}
-
-/**
- * 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)) {
-    this.options[key] = _getBackgroundColourOption(value);
-  }
-}
-
-/**
- * Decorate the Sharp prototype with colour-related functions.
- * @module Sharp
- * @private
- */
-module.exports = (Sharp) => {
-  Object.assign(Sharp.prototype, {
-    // Public
-    tint,
-    greyscale,
-    grayscale,
-    pipelineColourspace,
-    pipelineColorspace,
-    toColourspace,
-    toColorspace,
-    // Private
-    _getBackgroundColourOption,
-    _setBackgroundColourOption
-  });
-  // Class attributes
-  Sharp.colourspace = colourspace;
-  Sharp.colorspace = colourspace;
-};