import { x as getDefaultExportFromCjs } from './entrypoint_CZ7e8met.mjs';
import require$$0$2 from 'node:util';
import require$$1$1 from 'node:stream';
import require$$4 from 'child_process';
import require$$0 from 'fs';
import require$$0$1 from 'node:child_process';
import require$$1 from 'node:crypto';
import nodePath from 'node:path';
import require$$0$3 from 'node:events';
import require$$7 from 'node:os';

function _mergeNamespaces(n, m) {
  for (var i = 0; i < m.length; i++) {
    const e = m[i];
    if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
      if (k !== 'default' && !(k in n)) {
        const d = Object.getOwnPropertyDescriptor(e, k);
        if (d) {
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: () => e[k]
          });
        }
      }
    } }
  }
  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var is;
var hasRequiredIs;

function requireIs () {
	if (hasRequiredIs) return is;
	hasRequiredIs = 1;
	/**
	 * Is this value defined and not null?
	 * @private
	 */
	const defined = (val) => typeof val !== 'undefined' && val !== null;

	/**
	 * Is this value an object?
	 * @private
	 */
	const object = (val) => typeof val === 'object';

	/**
	 * Is this value a plain object?
	 * @private
	 */
	const plainObject = (val) => Object.prototype.toString.call(val) === '[object Object]';

	/**
	 * Is this value a function?
	 * @private
	 */
	const fn = (val) => typeof val === 'function';

	/**
	 * Is this value a boolean?
	 * @private
	 */
	const bool = (val) => typeof val === 'boolean';

	/**
	 * Is this value a Buffer object?
	 * @private
	 */
	const buffer = (val) => val instanceof Buffer;

	/**
	 * Is this value a typed array object?. E.g. Uint8Array or Uint8ClampedArray?
	 * @private
	 */
	const typedArray = (val) => {
	  if (defined(val)) {
	    switch (val.constructor) {
	      case Uint8Array:
	      case Uint8ClampedArray:
	      case Int8Array:
	      case Uint16Array:
	      case Int16Array:
	      case Uint32Array:
	      case Int32Array:
	      case Float32Array:
	      case Float64Array:
	        return true;
	    }
	  }

	  return false;
	};

	/**
	 * Is this value an ArrayBuffer object?
	 * @private
	 */
	const arrayBuffer = (val) => val instanceof ArrayBuffer;

	/**
	 * Is this value a non-empty string?
	 * @private
	 */
	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);

	/**
	 * Is this value an integer?
	 * @private
	 */
	const integer = (val) => Number.isInteger(val);

	/**
	 * Is this value within an inclusive given range?
	 * @private
	 */
	const inRange = (val, min, max) => val >= min && val <= max;

	/**
	 * Is this value within the elements of an array?
	 * @private
	 */
	const inArray = (val, list) => list.includes(val);

	/**
	 * Create an Error with a message relating to an invalid parameter.
	 *
	 * @param {string} name - parameter name.
	 * @param {string} expected - description of the type/value/range expected.
	 * @param {*} actual - the value received.
	 * @returns {Error} Containing the formatted message.
	 * @private
	 */
	const invalidParameterError = (name, expected, actual) => new Error(
	    `Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`
	  );

	/**
	 * Ensures an Error from C++ contains a JS stack.
	 *
	 * @param {Error} native - Error with message from C++.
	 * @param {Error} context - Error with stack from JS.
	 * @returns {Error} Error with message and stack.
	 * @private
	 */
	const nativeError = (native, context) => {
	  context.message = native.message;
	  return context;
	};

	is = {
	  defined,
	  object,
	  plainObject,
	  fn,
	  bool,
	  buffer,
	  typedArray,
	  arrayBuffer,
	  string,
	  number,
	  integer,
	  inRange,
	  inArray,
	  invalidParameterError,
	  nativeError
	};
	return is;
}

function commonjsRequire(path) {
	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
}

var sharp = {exports: {}};

var process_1;
var hasRequiredProcess;

function requireProcess () {
	if (hasRequiredProcess) return process_1;
	hasRequiredProcess = 1;

	const isLinux = () => process.platform === 'linux';

	let report = null;
	const getReport = () => {
	  if (!report) {
	    /* istanbul ignore next */
	    if (isLinux() && process.report) {
	      const orig = process.report.excludeNetwork;
	      process.report.excludeNetwork = true;
	      report = process.report.getReport();
	      process.report.excludeNetwork = orig;
	    } else {
	      report = {};
	    }
	  }
	  return report;
	};

	process_1 = { isLinux, getReport };
	return process_1;
}

var filesystem;
var hasRequiredFilesystem;

function requireFilesystem () {
	if (hasRequiredFilesystem) return filesystem;
	hasRequiredFilesystem = 1;

	const fs = require$$0;

	const LDD_PATH = '/usr/bin/ldd';
	const SELF_PATH = '/proc/self/exe';
	const MAX_LENGTH = 2048;

	/**
	 * Read the content of a file synchronous
	 *
	 * @param {string} path
	 * @returns {Buffer}
	 */
	const readFileSync = (path) => {
	  const fd = fs.openSync(path, 'r');
	  const buffer = Buffer.alloc(MAX_LENGTH);
	  const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
	  fs.close(fd, () => {});
	  return buffer.subarray(0, bytesRead);
	};

	/**
	 * Read the content of a file
	 *
	 * @param {string} path
	 * @returns {Promise<Buffer>}
	 */
	const readFile = (path) => new Promise((resolve, reject) => {
	  fs.open(path, 'r', (err, fd) => {
	    if (err) {
	      reject(err);
	    } else {
	      const buffer = Buffer.alloc(MAX_LENGTH);
	      fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
	        resolve(buffer.subarray(0, bytesRead));
	        fs.close(fd, () => {});
	      });
	    }
	  });
	});

	filesystem = {
	  LDD_PATH,
	  SELF_PATH,
	  readFileSync,
	  readFile
	};
	return filesystem;
}

var elf;
var hasRequiredElf;

function requireElf () {
	if (hasRequiredElf) return elf;
	hasRequiredElf = 1;

	const interpreterPath = (elf) => {
	  if (elf.length < 64) {
	    return null;
	  }
	  if (elf.readUInt32BE(0) !== 0x7F454C46) {
	    // Unexpected magic bytes
	    return null;
	  }
	  if (elf.readUInt8(4) !== 2) {
	    // Not a 64-bit ELF
	    return null;
	  }
	  if (elf.readUInt8(5) !== 1) {
	    // Not little-endian
	    return null;
	  }
	  const offset = elf.readUInt32LE(32);
	  const size = elf.readUInt16LE(54);
	  const count = elf.readUInt16LE(56);
	  for (let i = 0; i < count; i++) {
	    const headerOffset = offset + (i * size);
	    const type = elf.readUInt32LE(headerOffset);
	    if (type === 3) {
	      const fileOffset = elf.readUInt32LE(headerOffset + 8);
	      const fileSize = elf.readUInt32LE(headerOffset + 32);
	      return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, '');
	    }
	  }
	  return null;
	};

	elf = {
	  interpreterPath
	};
	return elf;
}

var detectLibc;
var hasRequiredDetectLibc;

function requireDetectLibc () {
	if (hasRequiredDetectLibc) return detectLibc;
	hasRequiredDetectLibc = 1;

	const childProcess = require$$4;
	const { isLinux, getReport } = requireProcess();
	const { LDD_PATH, SELF_PATH, readFile, readFileSync } = requireFilesystem();
	const { interpreterPath } = requireElf();

	let cachedFamilyInterpreter;
	let cachedFamilyFilesystem;
	let cachedVersionFilesystem;

	const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';
	let commandOut = '';

	const safeCommand = () => {
	  if (!commandOut) {
	    return new Promise((resolve) => {
	      childProcess.exec(command, (err, out) => {
	        commandOut = err ? ' ' : out;
	        resolve(commandOut);
	      });
	    });
	  }
	  return commandOut;
	};

	const safeCommandSync = () => {
	  if (!commandOut) {
	    try {
	      commandOut = childProcess.execSync(command, { encoding: 'utf8' });
	    } catch (_err) {
	      commandOut = ' ';
	    }
	  }
	  return commandOut;
	};

	/**
	 * A String constant containing the value `glibc`.
	 * @type {string}
	 * @public
	 */
	const GLIBC = 'glibc';

	/**
	 * A Regexp constant to get the GLIBC Version.
	 * @type {string}
	 */
	const RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;

	/**
	 * A String constant containing the value `musl`.
	 * @type {string}
	 * @public
	 */
	const MUSL = 'musl';

	const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');

	const familyFromReport = () => {
	  const report = getReport();
	  if (report.header && report.header.glibcVersionRuntime) {
	    return GLIBC;
	  }
	  if (Array.isArray(report.sharedObjects)) {
	    if (report.sharedObjects.some(isFileMusl)) {
	      return MUSL;
	    }
	  }
	  return null;
	};

	const familyFromCommand = (out) => {
	  const [getconf, ldd1] = out.split(/[\r\n]+/);
	  if (getconf && getconf.includes(GLIBC)) {
	    return GLIBC;
	  }
	  if (ldd1 && ldd1.includes(MUSL)) {
	    return MUSL;
	  }
	  return null;
	};

	const familyFromInterpreterPath = (path) => {
	  if (path) {
	    if (path.includes('/ld-musl-')) {
	      return MUSL;
	    } else if (path.includes('/ld-linux-')) {
	      return GLIBC;
	    }
	  }
	  return null;
	};

	const getFamilyFromLddContent = (content) => {
	  content = content.toString();
	  if (content.includes('musl')) {
	    return MUSL;
	  }
	  if (content.includes('GNU C Library')) {
	    return GLIBC;
	  }
	  return null;
	};

	const familyFromFilesystem = async () => {
	  if (cachedFamilyFilesystem !== undefined) {
	    return cachedFamilyFilesystem;
	  }
	  cachedFamilyFilesystem = null;
	  try {
	    const lddContent = await readFile(LDD_PATH);
	    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
	  } catch (e) {}
	  return cachedFamilyFilesystem;
	};

	const familyFromFilesystemSync = () => {
	  if (cachedFamilyFilesystem !== undefined) {
	    return cachedFamilyFilesystem;
	  }
	  cachedFamilyFilesystem = null;
	  try {
	    const lddContent = readFileSync(LDD_PATH);
	    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
	  } catch (e) {}
	  return cachedFamilyFilesystem;
	};

	const familyFromInterpreter = async () => {
	  if (cachedFamilyInterpreter !== undefined) {
	    return cachedFamilyInterpreter;
	  }
	  cachedFamilyInterpreter = null;
	  try {
	    const selfContent = await readFile(SELF_PATH);
	    const path = interpreterPath(selfContent);
	    cachedFamilyInterpreter = familyFromInterpreterPath(path);
	  } catch (e) {}
	  return cachedFamilyInterpreter;
	};

	const familyFromInterpreterSync = () => {
	  if (cachedFamilyInterpreter !== undefined) {
	    return cachedFamilyInterpreter;
	  }
	  cachedFamilyInterpreter = null;
	  try {
	    const selfContent = readFileSync(SELF_PATH);
	    const path = interpreterPath(selfContent);
	    cachedFamilyInterpreter = familyFromInterpreterPath(path);
	  } catch (e) {}
	  return cachedFamilyInterpreter;
	};

	/**
	 * Resolves with the libc family when it can be determined, `null` otherwise.
	 * @returns {Promise<?string>}
	 */
	const family = async () => {
	  let family = null;
	  if (isLinux()) {
	    family = await familyFromInterpreter();
	    if (!family) {
	      family = await familyFromFilesystem();
	      if (!family) {
	        family = familyFromReport();
	      }
	      if (!family) {
	        const out = await safeCommand();
	        family = familyFromCommand(out);
	      }
	    }
	  }
	  return family;
	};

	/**
	 * Returns the libc family when it can be determined, `null` otherwise.
	 * @returns {?string}
	 */
	const familySync = () => {
	  let family = null;
	  if (isLinux()) {
	    family = familyFromInterpreterSync();
	    if (!family) {
	      family = familyFromFilesystemSync();
	      if (!family) {
	        family = familyFromReport();
	      }
	      if (!family) {
	        const out = safeCommandSync();
	        family = familyFromCommand(out);
	      }
	    }
	  }
	  return family;
	};

	/**
	 * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
	 * @returns {Promise<boolean>}
	 */
	const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;

	/**
	 * Returns `true` only when the platform is Linux and the libc family is not `glibc`.
	 * @returns {boolean}
	 */
	const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;

	const versionFromFilesystem = async () => {
	  if (cachedVersionFilesystem !== undefined) {
	    return cachedVersionFilesystem;
	  }
	  cachedVersionFilesystem = null;
	  try {
	    const lddContent = await readFile(LDD_PATH);
	    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
	    if (versionMatch) {
	      cachedVersionFilesystem = versionMatch[1];
	    }
	  } catch (e) {}
	  return cachedVersionFilesystem;
	};

	const versionFromFilesystemSync = () => {
	  if (cachedVersionFilesystem !== undefined) {
	    return cachedVersionFilesystem;
	  }
	  cachedVersionFilesystem = null;
	  try {
	    const lddContent = readFileSync(LDD_PATH);
	    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
	    if (versionMatch) {
	      cachedVersionFilesystem = versionMatch[1];
	    }
	  } catch (e) {}
	  return cachedVersionFilesystem;
	};

	const versionFromReport = () => {
	  const report = getReport();
	  if (report.header && report.header.glibcVersionRuntime) {
	    return report.header.glibcVersionRuntime;
	  }
	  return null;
	};

	const versionSuffix = (s) => s.trim().split(/\s+/)[1];

	const versionFromCommand = (out) => {
	  const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
	  if (getconf && getconf.includes(GLIBC)) {
	    return versionSuffix(getconf);
	  }
	  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
	    return versionSuffix(ldd2);
	  }
	  return null;
	};

	/**
	 * Resolves with the libc version when it can be determined, `null` otherwise.
	 * @returns {Promise<?string>}
	 */
	const version = async () => {
	  let version = null;
	  if (isLinux()) {
	    version = await versionFromFilesystem();
	    if (!version) {
	      version = versionFromReport();
	    }
	    if (!version) {
	      const out = await safeCommand();
	      version = versionFromCommand(out);
	    }
	  }
	  return version;
	};

	/**
	 * Returns the libc version when it can be determined, `null` otherwise.
	 * @returns {?string}
	 */
	const versionSync = () => {
	  let version = null;
	  if (isLinux()) {
	    version = versionFromFilesystemSync();
	    if (!version) {
	      version = versionFromReport();
	    }
	    if (!version) {
	      const out = safeCommandSync();
	      version = versionFromCommand(out);
	    }
	  }
	  return version;
	};

	detectLibc = {
	  GLIBC,
	  MUSL,
	  family,
	  familySync,
	  isNonGlibcLinux,
	  isNonGlibcLinuxSync,
	  version,
	  versionSync
	};
	return detectLibc;
}

var debug_1;
var hasRequiredDebug;

function requireDebug () {
	if (hasRequiredDebug) return debug_1;
	hasRequiredDebug = 1;

	const debug = (
	  typeof process === 'object' &&
	  process.env &&
	  process.env.NODE_DEBUG &&
	  /\bsemver\b/i.test(process.env.NODE_DEBUG)
	) ? (...args) => console.error('SEMVER', ...args)
	  : () => {};

	debug_1 = debug;
	return debug_1;
}

var constants;
var hasRequiredConstants;

function requireConstants () {
	if (hasRequiredConstants) return constants;
	hasRequiredConstants = 1;

	// Note: this is the semver.org version of the spec that it implements
	// Not necessarily the package version of this code.
	const SEMVER_SPEC_VERSION = '2.0.0';

	const MAX_LENGTH = 256;
	const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
	/* istanbul ignore next */ 9007199254740991;

	// Max safe segment length for coercion.
	const MAX_SAFE_COMPONENT_LENGTH = 16;

	// Max safe length for a build identifier. The max length minus 6 characters for
	// the shortest version with a build 0.0.0+BUILD.
	const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;

	const RELEASE_TYPES = [
	  'major',
	  'premajor',
	  'minor',
	  'preminor',
	  'patch',
	  'prepatch',
	  'prerelease',
	];

	constants = {
	  MAX_LENGTH,
	  MAX_SAFE_COMPONENT_LENGTH,
	  MAX_SAFE_BUILD_LENGTH,
	  MAX_SAFE_INTEGER,
	  RELEASE_TYPES,
	  SEMVER_SPEC_VERSION,
	  FLAG_INCLUDE_PRERELEASE: 0b001,
	  FLAG_LOOSE: 0b010,
	};
	return constants;
}

var re = {exports: {}};

var hasRequiredRe;

function requireRe () {
	if (hasRequiredRe) return re.exports;
	hasRequiredRe = 1;
	(function (module, exports$1) {

		const {
		  MAX_SAFE_COMPONENT_LENGTH,
		  MAX_SAFE_BUILD_LENGTH,
		  MAX_LENGTH,
		} = requireConstants();
		const debug = requireDebug();
		exports$1 = module.exports = {};

		// The actual regexps go on exports.re
		const re = exports$1.re = [];
		const safeRe = exports$1.safeRe = [];
		const src = exports$1.src = [];
		const safeSrc = exports$1.safeSrc = [];
		const t = exports$1.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-numeric identifiers include numeric identifiers but can be longer.
		// Therefore non-numeric 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$1.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$1.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$1.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;
}

var parseOptions_1;
var hasRequiredParseOptions;

function requireParseOptions () {
	if (hasRequiredParseOptions) return parseOptions_1;
	hasRequiredParseOptions = 1;

	// parse out just the options we care about
	const looseOption = Object.freeze({ loose: true });
	const emptyOpts = Object.freeze({ });
	const parseOptions = options => {
	  if (!options) {
	    return emptyOpts
	  }

	  if (typeof options !== 'object') {
	    return looseOption
	  }

	  return options
	};
	parseOptions_1 = parseOptions;
	return parseOptions_1;
}

var identifiers;
var hasRequiredIdentifiers;

function requireIdentifiers () {
	if (hasRequiredIdentifiers) return identifiers;
	hasRequiredIdentifiers = 1;

	const numeric = /^[0-9]+$/;
	const compareIdentifiers = (a, b) => {
	  if (typeof a === 'number' && typeof b === 'number') {
	    return a === b ? 0 : a < b ? -1 : 1
	  }

	  const anum = numeric.test(a);
	  const bnum = numeric.test(b);

	  if (anum && bnum) {
	    a = +a;
	    b = +b;
	  }

	  return a === b ? 0
	    : (anum && !bnum) ? -1
	    : (bnum && !anum) ? 1
	    : a < b ? -1
	    : 1
	};

	const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);

	identifiers = {
	  compareIdentifiers,
	  rcompareIdentifiers,
	};
	return identifiers;
}

var semver;
var hasRequiredSemver;

function requireSemver () {
	if (hasRequiredSemver) return semver;
	hasRequiredSemver = 1;

	const debug = requireDebug();
	const { MAX_LENGTH, MAX_SAFE_INTEGER } = requireConstants();
	const { safeRe: re, t } = requireRe();

	const parseOptions = requireParseOptions();
	const { compareIdentifiers } = requireIdentifiers();
	class SemVer {
	  constructor (version, options) {
	    options = parseOptions(options);

	    if (version instanceof SemVer) {
	      if (version.loose === !!options.loose &&
	        version.includePrerelease === !!options.includePrerelease) {
	        return version
	      } else {
	        version = version.version;
	      }
	    } else if (typeof version !== 'string') {
	      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
	    }

	    if (version.length > MAX_LENGTH) {
	      throw new TypeError(
	        `version is longer than ${MAX_LENGTH} characters`
	      )
	    }

	    debug('SemVer', version, options);
	    this.options = options;
	    this.loose = !!options.loose;
	    // this isn't actually relevant for versions, but keep it so that we
	    // don't run into trouble passing this.options around.
	    this.includePrerelease = !!options.includePrerelease;

	    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);

	    if (!m) {
	      throw new TypeError(`Invalid Version: ${version}`)
	    }

	    this.raw = version;

	    // these are actually numbers
	    this.major = +m[1];
	    this.minor = +m[2];
	    this.patch = +m[3];

	    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
	      throw new TypeError('Invalid major version')
	    }

	    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
	      throw new TypeError('Invalid minor version')
	    }

	    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
	      throw new TypeError('Invalid patch version')
	    }

	    // numberify any prerelease numeric ids
	    if (!m[4]) {
	      this.prerelease = [];
	    } else {
	      this.prerelease = m[4].split('.').map((id) => {
	        if (/^[0-9]+$/.test(id)) {
	          const num = +id;
	          if (num >= 0 && num < MAX_SAFE_INTEGER) {
	            return num
	          }
	        }
	        return id
	      });
	    }

	    this.build = m[5] ? m[5].split('.') : [];
	    this.format();
	  }

	  format () {
	    this.version = `${this.major}.${this.minor}.${this.patch}`;
	    if (this.prerelease.length) {
	      this.version += `-${this.prerelease.join('.')}`;
	    }
	    return this.version
	  }

	  toString () {
	    return this.version
	  }

	  compare (other) {
	    debug('SemVer.compare', this.version, this.options, other);
	    if (!(other instanceof SemVer)) {
	      if (typeof other === 'string' && other === this.version) {
	        return 0
	      }
	      other = new SemVer(other, this.options);
	    }

	    if (other.version === this.version) {
	      return 0
	    }

	    return this.compareMain(other) || this.comparePre(other)
	  }

	  compareMain (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }

	    if (this.major < other.major) {
	      return -1
	    }
	    if (this.major > other.major) {
	      return 1
	    }
	    if (this.minor < other.minor) {
	      return -1
	    }
	    if (this.minor > other.minor) {
	      return 1
	    }
	    if (this.patch < other.patch) {
	      return -1
	    }
	    if (this.patch > other.patch) {
	      return 1
	    }
	    return 0
	  }

	  comparePre (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }

	    // NOT having a prerelease is > having one
	    if (this.prerelease.length && !other.prerelease.length) {
	      return -1
	    } else if (!this.prerelease.length && other.prerelease.length) {
	      return 1
	    } else if (!this.prerelease.length && !other.prerelease.length) {
	      return 0
	    }

	    let i = 0;
	    do {
	      const a = this.prerelease[i];
	      const b = other.prerelease[i];
	      debug('prerelease compare', i, a, b);
	      if (a === undefined && b === undefined) {
	        return 0
	      } else if (b === undefined) {
	        return 1
	      } else if (a === undefined) {
	        return -1
	      } else if (a === b) {
	        continue
	      } else {
	        return compareIdentifiers(a, b)
	      }
	    } while (++i)
	  }

	  compareBuild (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }

	    let i = 0;
	    do {
	      const a = this.build[i];
	      const b = other.build[i];
	      debug('build compare', i, a, b);
	      if (a === undefined && b === undefined) {
	        return 0
	      } else if (b === undefined) {
	        return 1
	      } else if (a === undefined) {
	        return -1
	      } else if (a === b) {
	        continue
	      } else {
	        return compareIdentifiers(a, b)
	      }
	    } while (++i)
	  }

	  // preminor will bump the version up to the next minor release, and immediately
	  // down to pre-release. premajor and prepatch work the same way.
	  inc (release, identifier, identifierBase) {
	    if (release.startsWith('pre')) {
	      if (!identifier && identifierBase === false) {
	        throw new Error('invalid increment argument: identifier is empty')
	      }
	      // Avoid an invalid semver results
	      if (identifier) {
	        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
	        if (!match || match[1] !== identifier) {
	          throw new Error(`invalid identifier: ${identifier}`)
	        }
	      }
	    }

	    switch (release) {
	      case 'premajor':
	        this.prerelease.length = 0;
	        this.patch = 0;
	        this.minor = 0;
	        this.major++;
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'preminor':
	        this.prerelease.length = 0;
	        this.patch = 0;
	        this.minor++;
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'prepatch':
	        // If this is already a prerelease, it will bump to the next version
	        // drop any prereleases that might already exist, since they are not
	        // relevant at this point.
	        this.prerelease.length = 0;
	        this.inc('patch', identifier, identifierBase);
	        this.inc('pre', identifier, identifierBase);
	        break
	      // If the input is a non-prerelease version, this acts the same as
	      // prepatch.
	      case 'prerelease':
	        if (this.prerelease.length === 0) {
	          this.inc('patch', identifier, identifierBase);
	        }
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'release':
	        if (this.prerelease.length === 0) {
	          throw new Error(`version ${this.raw} is not a prerelease`)
	        }
	        this.prerelease.length = 0;
	        break

	      case 'major':
	        // If this is a pre-major version, bump up to the same major version.
	        // Otherwise increment major.
	        // 1.0.0-5 bumps to 1.0.0
	        // 1.1.0 bumps to 2.0.0
	        if (
	          this.minor !== 0 ||
	          this.patch !== 0 ||
	          this.prerelease.length === 0
	        ) {
	          this.major++;
	        }
	        this.minor = 0;
	        this.patch = 0;
	        this.prerelease = [];
	        break
	      case 'minor':
	        // If this is a pre-minor version, bump up to the same minor version.
	        // Otherwise increment minor.
	        // 1.2.0-5 bumps to 1.2.0
	        // 1.2.1 bumps to 1.3.0
	        if (this.patch !== 0 || this.prerelease.length === 0) {
	          this.minor++;
	        }
	        this.patch = 0;
	        this.prerelease = [];
	        break
	      case 'patch':
	        // If this is not a pre-release version, it will increment the patch.
	        // If it is a pre-release it will bump up to the same patch version.
	        // 1.2.0-5 patches to 1.2.0
	        // 1.2.0 patches to 1.2.1
	        if (this.prerelease.length === 0) {
	          this.patch++;
	        }
	        this.prerelease = [];
	        break
	      // This probably shouldn't be used publicly.
	      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
	      case 'pre': {
	        const base = Number(identifierBase) ? 1 : 0;

	        if (this.prerelease.length === 0) {
	          this.prerelease = [base];
	        } else {
	          let i = this.prerelease.length;
	          while (--i >= 0) {
	            if (typeof this.prerelease[i] === 'number') {
	              this.prerelease[i]++;
	              i = -2;
	            }
	          }
	          if (i === -1) {
	            // didn't increment anything
	            if (identifier === this.prerelease.join('.') && identifierBase === false) {
	              throw new Error('invalid increment argument: identifier already exists')
	            }
	            this.prerelease.push(base);
	          }
	        }
	        if (identifier) {
	          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
	          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
	          let prerelease = [identifier, base];
	          if (identifierBase === false) {
	            prerelease = [identifier];
	          }
	          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
	            if (isNaN(this.prerelease[1])) {
	              this.prerelease = prerelease;
	            }
	          } else {
	            this.prerelease = prerelease;
	          }
	        }
	        break
	      }
	      default:
	        throw new Error(`invalid increment argument: ${release}`)
	    }
	    this.raw = this.format();
	    if (this.build.length) {
	      this.raw += `+${this.build.join('.')}`;
	    }
	    return this
	  }
	}

	semver = SemVer;
	return semver;
}

var parse_1;
var hasRequiredParse;

function requireParse () {
	if (hasRequiredParse) return parse_1;
	hasRequiredParse = 1;

	const SemVer = requireSemver();
	const parse = (version, options, throwErrors = false) => {
	  if (version instanceof SemVer) {
	    return version
	  }
	  try {
	    return new SemVer(version, options)
	  } catch (er) {
	    if (!throwErrors) {
	      return null
	    }
	    throw er
	  }
	};

	parse_1 = parse;
	return parse_1;
}

var coerce_1;
var hasRequiredCoerce;

function requireCoerce () {
	if (hasRequiredCoerce) return coerce_1;
	hasRequiredCoerce = 1;

	const SemVer = requireSemver();
	const parse = requireParse();
	const { safeRe: re, t } = requireRe();

	const coerce = (version, options) => {
	  if (version instanceof SemVer) {
	    return version
	  }

	  if (typeof version === 'number') {
	    version = String(version);
	  }

	  if (typeof version !== 'string') {
	    return null
	  }

	  options = options || {};

	  let match = null;
	  if (!options.rtl) {
	    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
	  } else {
	    // Find the right-most coercible string that does not share
	    // a terminus with a more left-ward coercible string.
	    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
	    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
	    //
	    // Walk through the string checking with a /g regexp
	    // Manually set the index so as to pick up overlapping matches.
	    // Stop when we get a match that ends at the string end, since no
	    // coercible string can be more right-ward without the same terminus.
	    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
	    let next;
	    while ((next = coerceRtlRegex.exec(version)) &&
	        (!match || match.index + match[0].length !== version.length)
	    ) {
	      if (!match ||
	            next.index + next[0].length !== match.index + match[0].length) {
	        match = next;
	      }
	      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
	    }
	    // leave it in a clean state
	    coerceRtlRegex.lastIndex = -1;
	  }

	  if (match === null) {
	    return null
	  }

	  const major = match[2];
	  const minor = match[3] || '0';
	  const patch = match[4] || '0';
	  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : '';
	  const build = options.includePrerelease && match[6] ? `+${match[6]}` : '';

	  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
	};
	coerce_1 = coerce;
	return coerce_1;
}

var compare_1;
var hasRequiredCompare;

function requireCompare () {
	if (hasRequiredCompare) return compare_1;
	hasRequiredCompare = 1;

	const SemVer = requireSemver();
	const compare = (a, b, loose) =>
	  new SemVer(a, loose).compare(new SemVer(b, loose));

	compare_1 = compare;
	return compare_1;
}

var gte_1;
var hasRequiredGte;

function requireGte () {
	if (hasRequiredGte) return gte_1;
	hasRequiredGte = 1;

	const compare = requireCompare();
	const gte = (a, b, loose) => compare(a, b, loose) >= 0;
	gte_1 = gte;
	return gte_1;
}

var lrucache;
var hasRequiredLrucache;

function requireLrucache () {
	if (hasRequiredLrucache) return lrucache;
	hasRequiredLrucache = 1;

	class LRUCache {
	  constructor () {
	    this.max = 1000;
	    this.map = new Map();
	  }

	  get (key) {
	    const value = this.map.get(key);
	    if (value === undefined) {
	      return undefined
	    } else {
	      // Remove the key from the map and add it to the end
	      this.map.delete(key);
	      this.map.set(key, value);
	      return value
	    }
	  }

	  delete (key) {
	    return this.map.delete(key)
	  }

	  set (key, value) {
	    const deleted = this.delete(key);

	    if (!deleted && value !== undefined) {
	      // If cache is full, delete the least recently used item
	      if (this.map.size >= this.max) {
	        const firstKey = this.map.keys().next().value;
	        this.delete(firstKey);
	      }

	      this.map.set(key, value);
	    }

	    return this
	  }
	}

	lrucache = LRUCache;
	return lrucache;
}

var eq_1;
var hasRequiredEq;

function requireEq () {
	if (hasRequiredEq) return eq_1;
	hasRequiredEq = 1;

	const compare = requireCompare();
	const eq = (a, b, loose) => compare(a, b, loose) === 0;
	eq_1 = eq;
	return eq_1;
}

var neq_1;
var hasRequiredNeq;

function requireNeq () {
	if (hasRequiredNeq) return neq_1;
	hasRequiredNeq = 1;

	const compare = requireCompare();
	const neq = (a, b, loose) => compare(a, b, loose) !== 0;
	neq_1 = neq;
	return neq_1;
}

var gt_1;
var hasRequiredGt;

function requireGt () {
	if (hasRequiredGt) return gt_1;
	hasRequiredGt = 1;

	const compare = requireCompare();
	const gt = (a, b, loose) => compare(a, b, loose) > 0;
	gt_1 = gt;
	return gt_1;
}

var lt_1;
var hasRequiredLt;

function requireLt () {
	if (hasRequiredLt) return lt_1;
	hasRequiredLt = 1;

	const compare = requireCompare();
	const lt = (a, b, loose) => compare(a, b, loose) < 0;
	lt_1 = lt;
	return lt_1;
}

var lte_1;
var hasRequiredLte;

function requireLte () {
	if (hasRequiredLte) return lte_1;
	hasRequiredLte = 1;

	const compare = requireCompare();
	const lte = (a, b, loose) => compare(a, b, loose) <= 0;
	lte_1 = lte;
	return lte_1;
}

var cmp_1;
var hasRequiredCmp;

function requireCmp () {
	if (hasRequiredCmp) return cmp_1;
	hasRequiredCmp = 1;

	const eq = requireEq();
	const neq = requireNeq();
	const gt = requireGt();
	const gte = requireGte();
	const lt = requireLt();
	const lte = requireLte();

	const cmp = (a, op, b, loose) => {
	  switch (op) {
	    case '===':
	      if (typeof a === 'object') {
	        a = a.version;
	      }
	      if (typeof b === 'object') {
	        b = b.version;
	      }
	      return a === b

	    case '!==':
	      if (typeof a === 'object') {
	        a = a.version;
	      }
	      if (typeof b === 'object') {
	        b = b.version;
	      }
	      return a !== b

	    case '':
	    case '=':
	    case '==':
	      return eq(a, b, loose)

	    case '!=':
	      return neq(a, b, loose)

	    case '>':
	      return gt(a, b, loose)

	    case '>=':
	      return gte(a, b, loose)

	    case '<':
	      return lt(a, b, loose)

	    case '<=':
	      return lte(a, b, loose)

	    default:
	      throw new TypeError(`Invalid operator: ${op}`)
	  }
	};
	cmp_1 = cmp;
	return cmp_1;
}

var comparator;
var hasRequiredComparator;

function requireComparator () {
	if (hasRequiredComparator) return comparator;
	hasRequiredComparator = 1;

	const ANY = Symbol('SemVer ANY');
	// hoisted class for cyclic dependency
	class Comparator {
	  static get ANY () {
	    return ANY
	  }

	  constructor (comp, options) {
	    options = parseOptions(options);

	    if (comp instanceof Comparator) {
	      if (comp.loose === !!options.loose) {
	        return comp
	      } else {
	        comp = comp.value;
	      }
	    }

	    comp = comp.trim().split(/\s+/).join(' ');
	    debug('comparator', comp, options);
	    this.options = options;
	    this.loose = !!options.loose;
	    this.parse(comp);

	    if (this.semver === ANY) {
	      this.value = '';
	    } else {
	      this.value = this.operator + this.semver.version;
	    }

	    debug('comp', this);
	  }

	  parse (comp) {
	    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
	    const m = comp.match(r);

	    if (!m) {
	      throw new TypeError(`Invalid comparator: ${comp}`)
	    }

	    this.operator = m[1] !== undefined ? m[1] : '';
	    if (this.operator === '=') {
	      this.operator = '';
	    }

	    // if it literally is just '>' or '' then allow anything.
	    if (!m[2]) {
	      this.semver = ANY;
	    } else {
	      this.semver = new SemVer(m[2], this.options.loose);
	    }
	  }

	  toString () {
	    return this.value
	  }

	  test (version) {
	    debug('Comparator.test', version, this.options.loose);

	    if (this.semver === ANY || version === ANY) {
	      return true
	    }

	    if (typeof version === 'string') {
	      try {
	        version = new SemVer(version, this.options);
	      } catch (er) {
	        return false
	      }
	    }

	    return cmp(version, this.operator, this.semver, this.options)
	  }

	  intersects (comp, options) {
	    if (!(comp instanceof Comparator)) {
	      throw new TypeError('a Comparator is required')
	    }

	    if (this.operator === '') {
	      if (this.value === '') {
	        return true
	      }
	      return new Range(comp.value, options).test(this.value)
	    } else if (comp.operator === '') {
	      if (comp.value === '') {
	        return true
	      }
	      return new Range(this.value, options).test(comp.semver)
	    }

	    options = parseOptions(options);

	    // Special cases where nothing can possibly be lower
	    if (options.includePrerelease &&
	      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
	      return false
	    }
	    if (!options.includePrerelease &&
	      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
	      return false
	    }

	    // Same direction increasing (> or >=)
	    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
	      return true
	    }
	    // Same direction decreasing (< or <=)
	    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
	      return true
	    }
	    // same SemVer and both sides are inclusive (<= or >=)
	    if (
	      (this.semver.version === comp.semver.version) &&
	      this.operator.includes('=') && comp.operator.includes('=')) {
	      return true
	    }
	    // opposite directions less than
	    if (cmp(this.semver, '<', comp.semver, options) &&
	      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
	      return true
	    }
	    // opposite directions greater than
	    if (cmp(this.semver, '>', comp.semver, options) &&
	      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
	      return true
	    }
	    return false
	  }
	}

	comparator = Comparator;

	const parseOptions = requireParseOptions();
	const { safeRe: re, t } = requireRe();
	const cmp = requireCmp();
	const debug = requireDebug();
	const SemVer = requireSemver();
	const Range = requireRange();
	return comparator;
}

var range;
var hasRequiredRange;

function requireRange () {
	if (hasRequiredRange) return range;
	hasRequiredRange = 1;

	const SPACE_CHARACTERS = /\s+/g;

	// hoisted class for cyclic dependency
	class Range {
	  constructor (range, options) {
	    options = parseOptions(options);

	    if (range instanceof Range) {
	      if (
	        range.loose === !!options.loose &&
	        range.includePrerelease === !!options.includePrerelease
	      ) {
	        return range
	      } else {
	        return new Range(range.raw, options)
	      }
	    }

	    if (range instanceof Comparator) {
	      // just put it in the set and return
	      this.raw = range.value;
	      this.set = [[range]];
	      this.formatted = undefined;
	      return this
	    }

	    this.options = options;
	    this.loose = !!options.loose;
	    this.includePrerelease = !!options.includePrerelease;

	    // First reduce all whitespace as much as possible so we do not have to rely
	    // on potentially slow regexes like \s*. This is then stored and used for
	    // future error messages as well.
	    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');

	    // First, split on ||
	    this.set = this.raw
	      .split('||')
	      // map the range to a 2d array of comparators
	      .map(r => this.parseRange(r.trim()))
	      // throw out any comparator lists that are empty
	      // this generally means that it was not a valid range, which is allowed
	      // in loose mode, but will still throw if the WHOLE range is invalid.
	      .filter(c => c.length);

	    if (!this.set.length) {
	      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
	    }

	    // if we have any that are not the null set, throw out null sets.
	    if (this.set.length > 1) {
	      // keep the first one, in case they're all null sets
	      const first = this.set[0];
	      this.set = this.set.filter(c => !isNullSet(c[0]));
	      if (this.set.length === 0) {
	        this.set = [first];
	      } else if (this.set.length > 1) {
	        // if we have any that are *, then the range is just *
	        for (const c of this.set) {
	          if (c.length === 1 && isAny(c[0])) {
	            this.set = [c];
	            break
	          }
	        }
	      }
	    }

	    this.formatted = undefined;
	  }

	  get range () {
	    if (this.formatted === undefined) {
	      this.formatted = '';
	      for (let i = 0; i < this.set.length; i++) {
	        if (i > 0) {
	          this.formatted += '||';
	        }
	        const comps = this.set[i];
	        for (let k = 0; k < comps.length; k++) {
	          if (k > 0) {
	            this.formatted += ' ';
	          }
	          this.formatted += comps[k].toString().trim();
	        }
	      }
	    }
	    return this.formatted
	  }

	  format () {
	    return this.range
	  }

	  toString () {
	    return this.range
	  }

	  parseRange (range) {
	    // memoize range parsing for performance.
	    // this is a very hot path, and fully deterministic.
	    const memoOpts =
	      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
	      (this.options.loose && FLAG_LOOSE);
	    const memoKey = memoOpts + ':' + range;
	    const cached = cache.get(memoKey);
	    if (cached) {
	      return cached
	    }

	    const loose = this.options.loose;
	    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
	    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
	    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
	    debug('hyphen replace', range);

	    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
	    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
	    debug('comparator trim', range);

	    // `~ 1.2.3` => `~1.2.3`
	    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
	    debug('tilde trim', range);

	    // `^ 1.2.3` => `^1.2.3`
	    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
	    debug('caret trim', range);

	    // At this point, the range is completely trimmed and
	    // ready to be split into comparators.

	    let rangeList = range
	      .split(' ')
	      .map(comp => parseComparator(comp, this.options))
	      .join(' ')
	      .split(/\s+/)
	      // >=0.0.0 is equivalent to *
	      .map(comp => replaceGTE0(comp, this.options));

	    if (loose) {
	      // in loose mode, throw out any that are not valid comparators
	      rangeList = rangeList.filter(comp => {
	        debug('loose invalid filter', comp, this.options);
	        return !!comp.match(re[t.COMPARATORLOOSE])
	      });
	    }
	    debug('range list', rangeList);

	    // if any comparators are the null set, then replace with JUST null set
	    // if more than one comparator, remove any * comparators
	    // also, don't include the same comparator more than once
	    const rangeMap = new Map();
	    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
	    for (const comp of comparators) {
	      if (isNullSet(comp)) {
	        return [comp]
	      }
	      rangeMap.set(comp.value, comp);
	    }
	    if (rangeMap.size > 1 && rangeMap.has('')) {
	      rangeMap.delete('');
	    }

	    const result = [...rangeMap.values()];
	    cache.set(memoKey, result);
	    return result
	  }

	  intersects (range, options) {
	    if (!(range instanceof Range)) {
	      throw new TypeError('a Range is required')
	    }

	    return this.set.some((thisComparators) => {
	      return (
	        isSatisfiable(thisComparators, options) &&
	        range.set.some((rangeComparators) => {
	          return (
	            isSatisfiable(rangeComparators, options) &&
	            thisComparators.every((thisComparator) => {
	              return rangeComparators.every((rangeComparator) => {
	                return thisComparator.intersects(rangeComparator, options)
	              })
	            })
	          )
	        })
	      )
	    })
	  }

	  // if ANY of the sets match ALL of its comparators, then pass
	  test (version) {
	    if (!version) {
	      return false
	    }

	    if (typeof version === 'string') {
	      try {
	        version = new SemVer(version, this.options);
	      } catch (er) {
	        return false
	      }
	    }

	    for (let i = 0; i < this.set.length; i++) {
	      if (testSet(this.set[i], version, this.options)) {
	        return true
	      }
	    }
	    return false
	  }
	}

	range = Range;

	const LRU = requireLrucache();
	const cache = new LRU();

	const parseOptions = requireParseOptions();
	const Comparator = requireComparator();
	const debug = requireDebug();
	const SemVer = requireSemver();
	const {
	  safeRe: re,
	  t,
	  comparatorTrimReplace,
	  tildeTrimReplace,
	  caretTrimReplace,
	} = requireRe();
	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = requireConstants();

	const isNullSet = c => c.value === '<0.0.0-0';
	const isAny = c => c.value === '';

	// take a set of comparators and determine whether there
	// exists a version which can satisfy it
	const isSatisfiable = (comparators, options) => {
	  let result = true;
	  const remainingComparators = comparators.slice();
	  let testComparator = remainingComparators.pop();

	  while (result && remainingComparators.length) {
	    result = remainingComparators.every((otherComparator) => {
	      return testComparator.intersects(otherComparator, options)
	    });

	    testComparator = remainingComparators.pop();
	  }

	  return result
	};

	// comprised of xranges, tildes, stars, and gtlt's at this point.
	// already replaced the hyphen ranges
	// turn into a set of JUST comparators.
	const parseComparator = (comp, options) => {
	  comp = comp.replace(re[t.BUILD], '');
	  debug('comp', comp, options);
	  comp = replaceCarets(comp, options);
	  debug('caret', comp);
	  comp = replaceTildes(comp, options);
	  debug('tildes', comp);
	  comp = replaceXRanges(comp, options);
	  debug('xrange', comp);
	  comp = replaceStars(comp, options);
	  debug('stars', comp);
	  return comp
	};

	const isX = id => !id || id.toLowerCase() === 'x' || id === '*';

	// ~, ~> --> * (any, kinda silly)
	// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
	// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
	// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
	// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
	// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
	// ~0.0.1 --> >=0.0.1 <0.1.0-0
	const replaceTildes = (comp, options) => {
	  return comp
	    .trim()
	    .split(/\s+/)
	    .map((c) => replaceTilde(c, options))
	    .join(' ')
	};

	const replaceTilde = (comp, options) => {
	  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
	  return comp.replace(r, (_, M, m, p, pr) => {
	    debug('tilde', comp, _, M, m, p, pr);
	    let ret;

	    if (isX(M)) {
	      ret = '';
	    } else if (isX(m)) {
	      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
	    } else if (isX(p)) {
	      // ~1.2 == >=1.2.0 <1.3.0-0
	      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
	    } else if (pr) {
	      debug('replaceTilde pr', pr);
	      ret = `>=${M}.${m}.${p}-${pr
	      } <${M}.${+m + 1}.0-0`;
	    } else {
	      // ~1.2.3 == >=1.2.3 <1.3.0-0
	      ret = `>=${M}.${m}.${p
	      } <${M}.${+m + 1}.0-0`;
	    }

	    debug('tilde return', ret);
	    return ret
	  })
	};

	// ^ --> * (any, kinda silly)
	// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
	// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
	// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
	// ^1.2.3 --> >=1.2.3 <2.0.0-0
	// ^1.2.0 --> >=1.2.0 <2.0.0-0
	// ^0.0.1 --> >=0.0.1 <0.0.2-0
	// ^0.1.0 --> >=0.1.0 <0.2.0-0
	const replaceCarets = (comp, options) => {
	  return comp
	    .trim()
	    .split(/\s+/)
	    .map((c) => replaceCaret(c, options))
	    .join(' ')
	};

	const replaceCaret = (comp, options) => {
	  debug('caret', comp, options);
	  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
	  const z = options.includePrerelease ? '-0' : '';
	  return comp.replace(r, (_, M, m, p, pr) => {
	    debug('caret', comp, _, M, m, p, pr);
	    let ret;

	    if (isX(M)) {
	      ret = '';
	    } else if (isX(m)) {
	      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
	    } else if (isX(p)) {
	      if (M === '0') {
	        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
	      } else {
	        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
	      }
	    } else if (pr) {
	      debug('replaceCaret pr', pr);
	      if (M === '0') {
	        if (m === '0') {
	          ret = `>=${M}.${m}.${p}-${pr
	          } <${M}.${m}.${+p + 1}-0`;
	        } else {
	          ret = `>=${M}.${m}.${p}-${pr
	          } <${M}.${+m + 1}.0-0`;
	        }
	      } else {
	        ret = `>=${M}.${m}.${p}-${pr
	        } <${+M + 1}.0.0-0`;
	      }
	    } else {
	      debug('no pr');
	      if (M === '0') {
	        if (m === '0') {
	          ret = `>=${M}.${m}.${p
	          }${z} <${M}.${m}.${+p + 1}-0`;
	        } else {
	          ret = `>=${M}.${m}.${p
	          }${z} <${M}.${+m + 1}.0-0`;
	        }
	      } else {
	        ret = `>=${M}.${m}.${p
	        } <${+M + 1}.0.0-0`;
	      }
	    }

	    debug('caret return', ret);
	    return ret
	  })
	};

	const replaceXRanges = (comp, options) => {
	  debug('replaceXRanges', comp, options);
	  return comp
	    .split(/\s+/)
	    .map((c) => replaceXRange(c, options))
	    .join(' ')
	};

	const replaceXRange = (comp, options) => {
	  comp = comp.trim();
	  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
	  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
	    debug('xRange', comp, ret, gtlt, M, m, p, pr);
	    const xM = isX(M);
	    const xm = xM || isX(m);
	    const xp = xm || isX(p);
	    const anyX = xp;

	    if (gtlt === '=' && anyX) {
	      gtlt = '';
	    }

	    // if we're including prereleases in the match, then we need
	    // to fix this to -0, the lowest possible prerelease value
	    pr = options.includePrerelease ? '-0' : '';

	    if (xM) {
	      if (gtlt === '>' || gtlt === '<') {
	        // nothing is allowed
	        ret = '<0.0.0-0';
	      } else {
	        // nothing is forbidden
	        ret = '*';
	      }
	    } else if (gtlt && anyX) {
	      // we know patch is an x, because we have any x at all.
	      // replace X with 0
	      if (xm) {
	        m = 0;
	      }
	      p = 0;

	      if (gtlt === '>') {
	        // >1 => >=2.0.0
	        // >1.2 => >=1.3.0
	        gtlt = '>=';
	        if (xm) {
	          M = +M + 1;
	          m = 0;
	          p = 0;
	        } else {
	          m = +m + 1;
	          p = 0;
	        }
	      } else if (gtlt === '<=') {
	        // <=0.7.x is actually <0.8.0, since any 0.7.x should
	        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
	        gtlt = '<';
	        if (xm) {
	          M = +M + 1;
	        } else {
	          m = +m + 1;
	        }
	      }

	      if (gtlt === '<') {
	        pr = '-0';
	      }

	      ret = `${gtlt + M}.${m}.${p}${pr}`;
	    } else if (xm) {
	      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
	    } else if (xp) {
	      ret = `>=${M}.${m}.0${pr
	      } <${M}.${+m + 1}.0-0`;
	    }

	    debug('xRange return', ret);

	    return ret
	  })
	};

	// Because * is AND-ed with everything else in the comparator,
	// and '' means "any version", just remove the *s entirely.
	const replaceStars = (comp, options) => {
	  debug('replaceStars', comp, options);
	  // Looseness is ignored here.  star is always as loose as it gets!
	  return comp
	    .trim()
	    .replace(re[t.STAR], '')
	};

	const replaceGTE0 = (comp, options) => {
	  debug('replaceGTE0', comp, options);
	  return comp
	    .trim()
	    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
	};

	// This function is passed to string.replace(re[t.HYPHENRANGE])
	// M, m, patch, prerelease, build
	// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
	// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
	// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
	// TODO build?
	const hyphenReplace = incPr => ($0,
	  from, fM, fm, fp, fpr, fb,
	  to, tM, tm, tp, tpr) => {
	  if (isX(fM)) {
	    from = '';
	  } else if (isX(fm)) {
	    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
	  } else if (isX(fp)) {
	    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
	  } else if (fpr) {
	    from = `>=${from}`;
	  } else {
	    from = `>=${from}${incPr ? '-0' : ''}`;
	  }

	  if (isX(tM)) {
	    to = '';
	  } else if (isX(tm)) {
	    to = `<${+tM + 1}.0.0-0`;
	  } else if (isX(tp)) {
	    to = `<${tM}.${+tm + 1}.0-0`;
	  } else if (tpr) {
	    to = `<=${tM}.${tm}.${tp}-${tpr}`;
	  } else if (incPr) {
	    to = `<${tM}.${tm}.${+tp + 1}-0`;
	  } else {
	    to = `<=${to}`;
	  }

	  return `${from} ${to}`.trim()
	};

	const testSet = (set, version, options) => {
	  for (let i = 0; i < set.length; i++) {
	    if (!set[i].test(version)) {
	      return false
	    }
	  }

	  if (version.prerelease.length && !options.includePrerelease) {
	    // Find the set of versions that are allowed to have prereleases
	    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
	    // That should allow `1.2.3-pr.2` to pass.
	    // However, `1.2.4-alpha.notready` should NOT be allowed,
	    // even though it's within the range set by the comparators.
	    for (let i = 0; i < set.length; i++) {
	      debug(set[i].semver);
	      if (set[i].semver === Comparator.ANY) {
	        continue
	      }

	      if (set[i].semver.prerelease.length > 0) {
	        const allowed = set[i].semver;
	        if (allowed.major === version.major &&
	            allowed.minor === version.minor &&
	            allowed.patch === version.patch) {
	          return true
	        }
	      }
	    }

	    // Version has a -pre, but it's not one of the ones we like.
	    return false
	  }

	  return true
	};
	return range;
}

var satisfies_1;
var hasRequiredSatisfies;

function requireSatisfies () {
	if (hasRequiredSatisfies) return satisfies_1;
	hasRequiredSatisfies = 1;

	const Range = requireRange();
	const satisfies = (version, range, options) => {
	  try {
	    range = new Range(range, options);
	  } catch (er) {
	    return false
	  }
	  return range.test(version)
	};
	satisfies_1 = satisfies;
	return satisfies_1;
}

const version = "0.34.5";
const optionalDependencies = {"@img/sharp-darwin-arm64":"0.34.5","@img/sharp-darwin-x64":"0.34.5","@img/sharp-libvips-darwin-arm64":"1.2.4","@img/sharp-libvips-darwin-x64":"1.2.4","@img/sharp-libvips-linux-arm":"1.2.4","@img/sharp-libvips-linux-arm64":"1.2.4","@img/sharp-libvips-linux-ppc64":"1.2.4","@img/sharp-libvips-linux-riscv64":"1.2.4","@img/sharp-libvips-linux-s390x":"1.2.4","@img/sharp-libvips-linux-x64":"1.2.4","@img/sharp-libvips-linuxmusl-arm64":"1.2.4","@img/sharp-libvips-linuxmusl-x64":"1.2.4","@img/sharp-linux-arm":"0.34.5","@img/sharp-linux-arm64":"0.34.5","@img/sharp-linux-ppc64":"0.34.5","@img/sharp-linux-riscv64":"0.34.5","@img/sharp-linux-s390x":"0.34.5","@img/sharp-linux-x64":"0.34.5","@img/sharp-linuxmusl-arm64":"0.34.5","@img/sharp-linuxmusl-x64":"0.34.5","@img/sharp-wasm32":"0.34.5","@img/sharp-win32-arm64":"0.34.5","@img/sharp-win32-ia32":"0.34.5","@img/sharp-win32-x64":"0.34.5"};
const engines = {"node":"^18.17.0 || ^20.3.0 || >=21.0.0"};
const config = {"libvips":">=8.17.3"};
const require$$6 = {
  version,
  optionalDependencies,
  engines,
  config};

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var libvips;
var hasRequiredLibvips;

function requireLibvips () {
	if (hasRequiredLibvips) return libvips;
	hasRequiredLibvips = 1;
	const { spawnSync } = require$$0$1;
	const { createHash } = require$$1;
	const semverCoerce = requireCoerce();
	const semverGreaterThanOrEqualTo = requireGte();
	const semverSatisfies = requireSatisfies();
	const detectLibc = requireDetectLibc();

	const { config, engines, optionalDependencies } = require$$6;

	/* node:coverage ignore next */
	const minimumLibvipsVersionLabelled = process.env.npm_package_config_libvips || config.libvips;
	const minimumLibvipsVersion = semverCoerce(minimumLibvipsVersionLabelled).version;

	const prebuiltPlatforms = [
	  'darwin-arm64', 'darwin-x64',
	  'linux-arm', 'linux-arm64', 'linux-ppc64', 'linux-riscv64', 'linux-s390x', 'linux-x64',
	  'linuxmusl-arm64', 'linuxmusl-x64',
	  'win32-arm64', 'win32-ia32', 'win32-x64'
	];

	const spawnSyncOptions = {
	  encoding: 'utf8',
	  shell: true
	};

	const log = (item) => {
	  if (item instanceof Error) {
	    console.error(`sharp: Installation error: ${item.message}`);
	  } else {
	    console.log(`sharp: ${item}`);
	  }
	};

	/* node:coverage ignore next */
	const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';

	const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;

	const buildPlatformArch = () => {
	  /* node:coverage ignore next 3 */
	  if (isEmscripten()) {
	    return 'wasm32';
	  }
	  const { npm_config_arch, npm_config_platform, npm_config_libc } = process.env;
	  const libc = typeof npm_config_libc === 'string' ? npm_config_libc : runtimeLibc();
	  return `${npm_config_platform || process.platform}${libc}-${npm_config_arch || process.arch}`;
	};

	const buildSharpLibvipsIncludeDir = () => {
	  try {
	    return commonjsRequire(`@img/sharp-libvips-dev-${buildPlatformArch()}/include`);
	  } catch {
	    /* node:coverage ignore next 5 */
	    try {
	      return require('@img/sharp-libvips-dev/include');
	    } catch {}
	  }
	  return '';
	};

	const buildSharpLibvipsCPlusPlusDir = () => {
	  /* node:coverage ignore next 4 */
	  try {
	    return require('@img/sharp-libvips-dev/cplusplus');
	  } catch {}
	  return '';
	};

	const buildSharpLibvipsLibDir = () => {
	  try {
	    return commonjsRequire(`@img/sharp-libvips-dev-${buildPlatformArch()}/lib`);
	  } catch {
	    /* node:coverage ignore next 5 */
	    try {
	      return commonjsRequire(`@img/sharp-libvips-${buildPlatformArch()}/lib`);
	    } catch {}
	  }
	  return '';
	};

	/* node:coverage disable */

	const isUnsupportedNodeRuntime = () => {
	  if (process.release?.name === 'node' && process.versions) {
	    if (!semverSatisfies(process.versions.node, engines.node)) {
	      return { found: process.versions.node, expected: engines.node };
	    }
	  }
	};

	const isEmscripten = () => {
	  const { CC } = process.env;
	  return Boolean(CC?.endsWith('/emcc'));
	};

	const isRosetta = () => {
	  if (process.platform === 'darwin' && process.arch === 'x64') {
	    const translated = spawnSync('sysctl sysctl.proc_translated', spawnSyncOptions).stdout;
	    return (translated || '').trim() === 'sysctl.proc_translated: 1';
	  }
	  return false;
	};

	/* node:coverage enable */

	const sha512 = (s) => createHash('sha512').update(s).digest('hex');

	const yarnLocator = () => {
	  try {
	    const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
	    const npmVersion = semverCoerce(optionalDependencies[`@img/sharp-libvips-${buildPlatformArch()}`], {
	      includePrerelease: true
	    }).version;
	    return sha512(`${identHash}npm:${npmVersion}`).slice(0, 10);
	  } catch {}
	  return '';
	};

	/* node:coverage disable */

	const spawnRebuild = () =>
	  spawnSync(`node-gyp rebuild --directory=src ${isEmscripten() ? '--nodedir=emscripten' : ''}`, {
	    ...spawnSyncOptions,
	    stdio: 'inherit'
	  }).status;

	const globalLibvipsVersion = () => {
	  if (process.platform !== 'win32') {
	    const globalLibvipsVersion = spawnSync('pkg-config --modversion vips-cpp', {
	      ...spawnSyncOptions,
	      env: {
	        ...process.env,
	        PKG_CONFIG_PATH: pkgConfigPath()
	      }
	    }).stdout;
	    return (globalLibvipsVersion || '').trim();
	  } else {
	    return '';
	  }
	};

	/* node:coverage enable */

	const pkgConfigPath = () => {
	  if (process.platform !== 'win32') {
	    /* node:coverage ignore next 4 */
	    const brewPkgConfigPath = spawnSync(
	      'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
	      spawnSyncOptions
	    ).stdout || '';
	    return [
	      brewPkgConfigPath.trim(),
	      process.env.PKG_CONFIG_PATH,
	      '/usr/local/lib/pkgconfig',
	      '/usr/lib/pkgconfig',
	      '/usr/local/libdata/pkgconfig',
	      '/usr/libdata/pkgconfig'
	    ].filter(Boolean).join(':');
	  } else {
	    return '';
	  }
	};

	const skipSearch = (status, reason, logger) => {
	  if (logger) {
	    logger(`Detected ${reason}, skipping search for globally-installed libvips`);
	  }
	  return status;
	};

	const useGlobalLibvips = (logger) => {
	  if (Boolean(process.env.SHARP_IGNORE_GLOBAL_LIBVIPS) === true) {
	    return skipSearch(false, 'SHARP_IGNORE_GLOBAL_LIBVIPS', logger);
	  }
	  if (Boolean(process.env.SHARP_FORCE_GLOBAL_LIBVIPS) === true) {
	    return skipSearch(true, 'SHARP_FORCE_GLOBAL_LIBVIPS', logger);
	  }
	  /* node:coverage ignore next 3 */
	  if (isRosetta()) {
	    return skipSearch(false, 'Rosetta', logger);
	  }
	  const globalVipsVersion = globalLibvipsVersion();
	  /* node:coverage ignore next */
	  return !!globalVipsVersion && semverGreaterThanOrEqualTo(globalVipsVersion, minimumLibvipsVersion);
	};

	libvips = {
	  minimumLibvipsVersion,
	  prebuiltPlatforms,
	  buildPlatformArch,
	  buildSharpLibvipsIncludeDir,
	  buildSharpLibvipsCPlusPlusDir,
	  buildSharpLibvipsLibDir,
	  isUnsupportedNodeRuntime,
	  runtimePlatformArch,
	  log,
	  yarnLocator,
	  spawnRebuild,
	  globalLibvipsVersion,
	  pkgConfigPath,
	  useGlobalLibvips
	};
	return libvips;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var hasRequiredSharp;

function requireSharp () {
	if (hasRequiredSharp) return sharp.exports;
	hasRequiredSharp = 1;
	// Inspects the runtime environment and exports the relevant sharp.node binary

	const { familySync, versionSync } = requireDetectLibc();

	const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = requireLibvips();
	const runtimePlatform = runtimePlatformArch();

	const paths = [
	  `../src/build/Release/sharp-${runtimePlatform}.node`,
	  '../src/build/Release/sharp-wasm32.node',
	  `@img/sharp-${runtimePlatform}/sharp.node`,
	  '@img/sharp-wasm32/sharp.node'
	];

	/* node:coverage disable */

	let path, sharp$1;
	const errors = [];
	for (path of paths) {
	  try {
	    sharp$1 = commonjsRequire(path);
	    break;
	  } catch (err) {
	    errors.push(err);
	  }
	}

	if (sharp$1 && path.startsWith('@img/sharp-linux-x64') && !sharp$1._isUsingX64V2()) {
	  const err = new Error('Prebuilt binaries for linux-x64 require v2 microarchitecture');
	  err.code = 'Unsupported CPU';
	  errors.push(err);
	  sharp$1 = null;
	}

	if (sharp$1) {
	  sharp.exports = sharp$1;
	} else {
	  const [isLinux, isMacOs, isWindows] = ['linux', 'darwin', 'win32'].map(os => runtimePlatform.startsWith(os));

	  const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
	  errors.forEach(err => {
	    if (err.code !== 'MODULE_NOT_FOUND') {
	      help.push(`${err.code}: ${err.message}`);
	    }
	  });
	  const messages = errors.map(err => err.message).join(' ');
	  help.push('Possible solutions:');
	  // Common error messages
	  if (isUnsupportedNodeRuntime()) {
	    const { found, expected } = isUnsupportedNodeRuntime();
	    help.push(
	      '- Please upgrade Node.js:',
	      `    Found ${found}`,
	      `    Requires ${expected}`
	    );
	  } else if (prebuiltPlatforms.includes(runtimePlatform)) {
	    const [os, cpu] = runtimePlatform.split('-');
	    const libc = os.endsWith('musl') ? ' --libc=musl' : '';
	    help.push(
	      '- Ensure optional dependencies can be installed:',
	      '    npm install --include=optional sharp',
	      '- Ensure your package manager supports multi-platform installation:',
	      '    See https://sharp.pixelplumbing.com/install#cross-platform',
	      '- Add platform-specific dependencies:',
	      `    npm install --os=${os.replace('musl', '')}${libc} --cpu=${cpu} sharp`
	    );
	  } else {
	    help.push(
	      `- Manually install libvips >= ${minimumLibvipsVersion}`,
	      '- Add experimental WebAssembly-based dependencies:',
	      '    npm install --cpu=wasm32 sharp',
	      '    npm install @img/sharp-wasm32'
	    );
	  }
	  if (isLinux && /(symbol not found|CXXABI_)/i.test(messages)) {
	    try {
	      const { config } = commonjsRequire(`@img/sharp-libvips-${runtimePlatform}/package`);
	      const libcFound = `${familySync()} ${versionSync()}`;
	      const libcRequires = `${config.musl ? 'musl' : 'glibc'} ${config.musl || config.glibc}`;
	      help.push(
	        '- Update your OS:',
	        `    Found ${libcFound}`,
	        `    Requires ${libcRequires}`
	      );
	    } catch (_errEngines) {}
	  }
	  if (isLinux && /\/snap\/core[0-9]{2}/.test(messages)) {
	    help.push(
	      '- Remove the Node.js Snap, which does not support native modules',
	      '    snap remove node'
	    );
	  }
	  if (isMacOs && /Incompatible library version/.test(messages)) {
	    help.push(
	      '- Update Homebrew:',
	      '    brew update && brew upgrade vips'
	    );
	  }
	  if (errors.some(err => err.code === 'ERR_DLOPEN_DISABLED')) {
	    help.push('- Run Node.js without using the --no-addons flag');
	  }
	  // Link to installation docs
	  if (isWindows && /The specified procedure could not be found/.test(messages)) {
	    help.push(
	      '- Using the canvas package on Windows?',
	      '    See https://sharp.pixelplumbing.com/install#canvas-and-windows',
	      '- Check for outdated versions of sharp in the dependency tree:',
	      '    npm ls sharp'
	    );
	  }
	  help.push(
	    '- Consult the installation documentation:',
	    '    See https://sharp.pixelplumbing.com/install'
	  );
	  throw new Error(help.join('\n'));
	}
	return sharp.exports;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var constructor;
var hasRequiredConstructor;

function requireConstructor () {
	if (hasRequiredConstructor) return constructor;
	hasRequiredConstructor = 1;
	const util = require$$0$2;
	const stream = require$$1$1;
	const is = requireIs();

	requireSharp();

	// Use NODE_DEBUG=sharp to enable libvips warnings
	const debuglog = util.debuglog('sharp');

	const queueListener = (queueLength) => {
	  Sharp.queue.emit('change', queueLength);
	};

	/**
	 * Constructor factory to create an instance of `sharp`, to which further methods are chained.
	 *
	 * JPEG, PNG, WebP, GIF, AVIF or TIFF format image data can be streamed out from this object.
	 * When using Stream based output, derived attributes are available from the `info` event.
	 *
	 * Non-critical problems encountered during processing are emitted as `warning` events.
	 *
	 * Implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
	 *
	 * When loading more than one page/frame of an animated image,
	 * these are combined as a vertically-stacked "toilet roll" image
	 * where the overall height is the `pageHeight` multiplied by the number of `pages`.
	 *
	 * @constructs Sharp
	 *
	 * @emits Sharp#info
	 * @emits Sharp#warning
	 *
	 * @example
	 * sharp('input.jpg')
	 *   .resize(300, 200)
	 *   .toFile('output.jpg', function(err) {
	 *     // output.jpg is a 300 pixels wide and 200 pixels high image
	 *     // containing a scaled and cropped version of input.jpg
	 *   });
	 *
	 * @example
	 * // Read image data from remote URL,
	 * // resize to 300 pixels wide,
	 * // emit an 'info' event with calculated dimensions
	 * // and finally write image data to writableStream
	 * const { body } = fetch('https://...');
	 * const readableStream = Readable.fromWeb(body);
	 * const transformer = sharp()
	 *   .resize(300)
	 *   .on('info', ({ height }) => {
	 *     console.log(`Image height is ${height}`);
	 *   });
	 * readableStream.pipe(transformer).pipe(writableStream);
	 *
	 * @example
	 * // Create a blank 300x200 PNG image of semi-translucent red pixels
	 * sharp({
	 *   create: {
	 *     width: 300,
	 *     height: 200,
	 *     channels: 4,
	 *     background: { r: 255, g: 0, b: 0, alpha: 0.5 }
	 *   }
	 * })
	 * .png()
	 * .toBuffer()
	 * .then( ... );
	 *
	 * @example
	 * // Convert an animated GIF to an animated WebP
	 * await sharp('in.gif', { animated: true }).toFile('out.webp');
	 *
	 * @example
	 * // Read a raw array of pixels and save it to a png
	 * const input = Uint8Array.from([255, 255, 255, 0, 0, 0]); // or Uint8ClampedArray
	 * const image = sharp(input, {
	 *   // because the input does not contain its dimensions or how many channels it has
	 *   // we need to specify it in the constructor options
	 *   raw: {
	 *     width: 2,
	 *     height: 1,
	 *     channels: 3
	 *   }
	 * });
	 * await image.toFile('my-two-pixels.png');
	 *
	 * @example
	 * // Generate RGB Gaussian noise
	 * await sharp({
	 *   create: {
	 *     width: 300,
	 *     height: 200,
	 *     channels: 3,
	 *     noise: {
	 *       type: 'gaussian',
	 *       mean: 128,
	 *       sigma: 30
	 *     }
	 *  }
	 * }).toFile('noise.png');
	 *
	 * @example
	 * // Generate an image from text
	 * await sharp({
	 *   text: {
	 *     text: 'Hello, world!',
	 *     width: 400, // max width
	 *     height: 300 // max height
	 *   }
	 * }).toFile('text_bw.png');
	 *
	 * @example
	 * // Generate an rgba image from text using pango markup and font
	 * await sharp({
	 *   text: {
	 *     text: '<span foreground="red">Red!</span><span background="cyan">blue</span>',
	 *     font: 'sans',
	 *     rgba: true,
	 *     dpi: 300
	 *   }
	 * }).toFile('text_rgba.png');
	 *
	 * @example
	 * // Join four input images as a 2x2 grid with a 4 pixel gutter
	 * const data = await sharp(
	 *  [image1, image2, image3, image4],
	 *  { join: { across: 2, shim: 4 } }
	 * ).toBuffer();
	 *
	 * @example
	 * // Generate a two-frame animated image from emoji
	 * const images = ['😀', '😛'].map(text => ({
	 *   text: { text, width: 64, height: 64, channels: 4, rgba: true }
	 * }));
	 * await sharp(images, { join: { animated: true } }).toFile('out.gif');
	 *
	 * @param {(Buffer|ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|Uint16Array|Int16Array|Uint32Array|Int32Array|Float32Array|Float64Array|string|Array)} [input] - if present, can be
	 *  a Buffer / ArrayBuffer / Uint8Array / Uint8ClampedArray containing JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image data, or
	 *  a TypedArray containing raw pixel image data, or
	 *  a String containing the filesystem path to an JPEG, PNG, WebP, AVIF, GIF, SVG or TIFF image file.
	 *  An array of inputs can be provided, and these will be joined together.
	 *  JPEG, PNG, WebP, AVIF, GIF, SVG, TIFF or raw pixel image data can be streamed into the object when not present.
	 * @param {Object} [options] - if present, is an Object with optional attributes.
	 * @param {string} [options.failOn='warning'] - When to abort processing of invalid pixel data, one of (in order of sensitivity, least to most): 'none', 'truncated', 'error', 'warning'. Higher levels imply lower levels. Invalid metadata will always abort.
	 * @param {number|boolean} [options.limitInputPixels=268402689] - Do not process input images where the number of pixels
	 *  (width x height) exceeds this limit. Assumes image dimensions contained in the input metadata can be trusted.
	 *  An integral Number of pixels, zero or false to remove limit, true to use default limit of 268402689 (0x3FFF x 0x3FFF).
	 * @param {boolean} [options.unlimited=false] - Set this to `true` to remove safety features that help prevent memory exhaustion (JPEG, PNG, SVG, HEIF).
	 * @param {boolean} [options.autoOrient=false] - Set this to `true` to rotate/flip the image to match EXIF `Orientation`, if any.
	 * @param {boolean} [options.sequentialRead=true] - Set this to `false` to use random access rather than sequential read. Some operations will do this automatically.
	 * @param {number} [options.density=72] - number representing the DPI for vector images in the range 1 to 100000.
	 * @param {number} [options.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 {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.
	 * @param {number} [options.raw.height] - integral number of pixels high.
	 * @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=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.
	 * @param {string} [options.text.fontfile] - absolute filesystem path to a font file that can be used by `font`.
	 * @param {number} [options.text.width=0] - Integral number of pixels to word-wrap at. Lines of text wider than this will be broken at word boundaries.
	 * @param {number} [options.text.height=0] - Maximum integral number of pixels high. When defined, `dpi` will be ignored and the text will automatically fit the pixel resolution defined by `width` and `height`. Will be ignored if `width` is not specified or set to 0.
	 * @param {string} [options.text.align='left'] - Alignment style for multi-line text (`'left'`, `'centre'`, `'center'`, `'right'`).
	 * @param {boolean} [options.text.justify=false] - set this to true to apply justification to the text.
	 * @param {number} [options.text.dpi=72] - the resolution (size) at which to render the text. Does not take effect if `height` is specified.
	 * @param {boolean} [options.text.rgba=false] - set this to true to enable RGBA output. This is useful for colour emoji rendering, or support for pango markup features like `<span foreground="red">Red!</span>`.
	 * @param {number} [options.text.spacing=0] - text line height in points. Will use the font line height if none is specified.
	 * @param {string} [options.text.wrap='word'] - word wrapping style when width is provided, one of: 'word', 'char', 'word-char' (prefer word, fallback to char) or 'none'.
	 * @param {Object} [options.join] - describes how an array of input images should be joined.
	 * @param {number} [options.join.across=1] - number of images to join horizontally.
	 * @param {boolean} [options.join.animated=false] - set this to `true` to join the images as an animated image.
	 * @param {number} [options.join.shim=0] - number of pixels to insert between joined images.
	 * @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
	 */
	const Sharp = function (input, options) {
	  // biome-ignore lint/complexity/noArguments: constructor factory
	  if (arguments.length === 1 && !is.defined(input)) {
	    throw new Error('Invalid input');
	  }
	  if (!(this instanceof Sharp)) {
	    return new Sharp(input, options);
	  }
	  stream.Duplex.call(this);
	  this.options = {
	    // resize options
	    topOffsetPre: -1,
	    leftOffsetPre: -1,
	    widthPre: -1,
	    heightPre: -1,
	    topOffsetPost: -1,
	    leftOffsetPost: -1,
	    widthPost: -1,
	    heightPost: -1,
	    width: -1,
	    height: -1,
	    canvas: 'crop',
	    position: 0,
	    resizeBackground: [0, 0, 0, 255],
	    angle: 0,
	    rotationAngle: 0,
	    rotationBackground: [0, 0, 0, 255],
	    rotateBefore: false,
	    orientBefore: false,
	    flip: false,
	    flop: false,
	    extendTop: 0,
	    extendBottom: 0,
	    extendLeft: 0,
	    extendRight: 0,
	    extendBackground: [0, 0, 0, 255],
	    extendWith: 'background',
	    withoutEnlargement: false,
	    withoutReduction: false,
	    affineMatrix: [],
	    affineBackground: [0, 0, 0, 255],
	    affineIdx: 0,
	    affineIdy: 0,
	    affineOdx: 0,
	    affineOdy: 0,
	    affineInterpolator: this.constructor.interpolators.bilinear,
	    kernel: 'lanczos3',
	    fastShrinkOnLoad: true,
	    // operations
	    tint: [-1, 0, 0, 0],
	    flatten: false,
	    flattenBackground: [0, 0, 0],
	    unflatten: false,
	    negate: false,
	    negateAlpha: true,
	    medianSize: 0,
	    blurSigma: 0,
	    precision: 'integer',
	    minAmpl: 0.2,
	    sharpenSigma: 0,
	    sharpenM1: 1,
	    sharpenM2: 2,
	    sharpenX1: 2,
	    sharpenY2: 10,
	    sharpenY3: 20,
	    threshold: 0,
	    thresholdGrayscale: true,
	    trimBackground: [],
	    trimThreshold: -1,
	    trimLineArt: false,
	    dilateWidth: 0,
	    erodeWidth: 0,
	    gamma: 0,
	    gammaOut: 0,
	    greyscale: false,
	    normalise: false,
	    normaliseLower: 1,
	    normaliseUpper: 99,
	    claheWidth: 0,
	    claheHeight: 0,
	    claheMaxSlope: 3,
	    brightness: 1,
	    saturation: 1,
	    hue: 0,
	    lightness: 0,
	    booleanBufferIn: null,
	    booleanFileIn: '',
	    joinChannelIn: [],
	    extractChannel: -1,
	    removeAlpha: false,
	    ensureAlpha: -1,
	    colourspace: 'srgb',
	    colourspacePipeline: 'last',
	    composite: [],
	    // output
	    fileOut: '',
	    formatOut: 'input',
	    streamOut: false,
	    keepMetadata: 0,
	    withMetadataOrientation: -1,
	    withMetadataDensity: 0,
	    withIccProfile: '',
	    withExif: {},
	    withExifMerge: true,
	    withXmp: '',
	    resolveWithObject: false,
	    loop: -1,
	    delay: [],
	    // output format
	    jpegQuality: 80,
	    jpegProgressive: false,
	    jpegChromaSubsampling: '4:2:0',
	    jpegTrellisQuantisation: false,
	    jpegOvershootDeringing: false,
	    jpegOptimiseScans: false,
	    jpegOptimiseCoding: true,
	    jpegQuantisationTable: 0,
	    pngProgressive: false,
	    pngCompressionLevel: 6,
	    pngAdaptiveFiltering: false,
	    pngPalette: false,
	    pngQuality: 100,
	    pngEffort: 7,
	    pngBitdepth: 8,
	    pngDither: 1,
	    jp2Quality: 80,
	    jp2TileHeight: 512,
	    jp2TileWidth: 512,
	    jp2Lossless: false,
	    jp2ChromaSubsampling: '4:4:4',
	    webpQuality: 80,
	    webpAlphaQuality: 100,
	    webpLossless: false,
	    webpNearLossless: false,
	    webpSmartSubsample: false,
	    webpSmartDeblock: false,
	    webpPreset: 'default',
	    webpEffort: 4,
	    webpMinSize: false,
	    webpMixed: false,
	    gifBitdepth: 8,
	    gifEffort: 7,
	    gifDither: 1,
	    gifInterFrameMaxError: 0,
	    gifInterPaletteMaxError: 3,
	    gifKeepDuplicateFrames: false,
	    gifReuse: true,
	    gifProgressive: false,
	    tiffQuality: 80,
	    tiffCompression: 'jpeg',
	    tiffBigtiff: false,
	    tiffPredictor: 'horizontal',
	    tiffPyramid: false,
	    tiffMiniswhite: false,
	    tiffBitdepth: 8,
	    tiffTile: false,
	    tiffTileHeight: 256,
	    tiffTileWidth: 256,
	    tiffXres: 1.0,
	    tiffYres: 1.0,
	    tiffResolutionUnit: 'inch',
	    heifQuality: 50,
	    heifLossless: false,
	    heifCompression: 'av1',
	    heifEffort: 4,
	    heifChromaSubsampling: '4:4:4',
	    heifBitdepth: 8,
	    jxlDistance: 1,
	    jxlDecodingTier: 0,
	    jxlEffort: 7,
	    jxlLossless: false,
	    rawDepth: 'uchar',
	    tileSize: 256,
	    tileOverlap: 0,
	    tileContainer: 'fs',
	    tileLayout: 'dz',
	    tileFormat: 'last',
	    tileDepth: 'last',
	    tileAngle: 0,
	    tileSkipBlanks: -1,
	    tileBackground: [255, 255, 255, 255],
	    tileCentre: false,
	    tileId: 'https://example.com/iiif',
	    tileBasename: '',
	    timeoutSeconds: 0,
	    linearA: [],
	    linearB: [],
	    pdfBackground: [255, 255, 255, 255],
	    // Function to notify of libvips warnings
	    debuglog: warning => {
	      this.emit('warning', warning);
	      debuglog(warning);
	    },
	    // Function to notify of queue length changes
	    queueListener
	  };
	  this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
	  return this;
	};
	Object.setPrototypeOf(Sharp.prototype, stream.Duplex.prototype);
	Object.setPrototypeOf(Sharp, stream.Duplex);

	/**
	 * Take a "snapshot" of the Sharp instance, returning a new instance.
	 * Cloned instances inherit the input of their parent instance.
	 * This allows multiple output Streams and therefore multiple processing pipelines to share a single input Stream.
	 *
	 * @example
	 * const pipeline = sharp().rotate();
	 * pipeline.clone().resize(800, 600).pipe(firstWritableStream);
	 * pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(secondWritableStream);
	 * readableStream.pipe(pipeline);
	 * // firstWritableStream receives auto-rotated, resized readableStream
	 * // secondWritableStream receives auto-rotated, extracted region of readableStream
	 *
	 * @example
	 * // Create a pipeline that will download an image, resize it and format it to different files
	 * // Using Promises to know when the pipeline is complete
	 * const fs = require("fs");
	 * const got = require("got");
	 * const sharpStream = sharp({ failOn: 'none' });
	 *
	 * const promises = [];
	 *
	 * promises.push(
	 *   sharpStream
	 *     .clone()
	 *     .jpeg({ quality: 100 })
	 *     .toFile("originalFile.jpg")
	 * );
	 *
	 * promises.push(
	 *   sharpStream
	 *     .clone()
	 *     .resize({ width: 500 })
	 *     .jpeg({ quality: 80 })
	 *     .toFile("optimized-500.jpg")
	 * );
	 *
	 * promises.push(
	 *   sharpStream
	 *     .clone()
	 *     .resize({ width: 500 })
	 *     .webp({ quality: 80 })
	 *     .toFile("optimized-500.webp")
	 * );
	 *
	 * // https://github.com/sindresorhus/got/blob/main/documentation/3-streams.md
	 * got.stream("https://www.example.com/some-file.jpg").pipe(sharpStream);
	 *
	 * Promise.all(promises)
	 *   .then(res => { console.log("Done!", res); })
	 *   .catch(err => {
	 *     console.error("Error processing files, let's clean it up", err);
	 *     try {
	 *       fs.unlinkSync("originalFile.jpg");
	 *       fs.unlinkSync("optimized-500.jpg");
	 *       fs.unlinkSync("optimized-500.webp");
	 *     } catch (e) {}
	 *   });
	 *
	 * @returns {Sharp}
	 */
	function clone () {
	  // Clone existing options
	  const clone = this.constructor.call();
	  const { debuglog, queueListener, ...options } = this.options;
	  clone.options = structuredClone(options);
	  clone.options.debuglog = debuglog;
	  clone.options.queueListener = queueListener;
	  // Pass 'finish' event to clone for Stream-based input
	  if (this._isStreamInput()) {
	    this.on('finish', () => {
	      // Clone inherits input data
	      this._flattenBufferIn();
	      clone.options.input.buffer = this.options.input.buffer;
	      clone.emit('finish');
	    });
	  }
	  return clone;
	}
	Object.assign(Sharp.prototype, { clone });

	/**
	 * Export constructor.
	 * @module Sharp
	 * @private
	 */
	constructor = Sharp;
	return constructor;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var input;
var hasRequiredInput;

function requireInput () {
	if (hasRequiredInput) return input;
	hasRequiredInput = 1;
	const is = requireIs();
	const sharp = requireSharp();

	/**
	 * Justification alignment
	 * @member
	 * @private
	 */
	const align = {
	  left: 'low',
	  top: 'low',
	  low: 'low',
	  center: 'centre',
	  centre: 'centre',
	  right: 'high',
	  bottom: 'high',
	  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 params = inputStreamParameters
	    .filter(p => is.defined(obj[p]))
	    .map(p => ([p, obj[p]]));
	  return params.length
	    ? Object.fromEntries(params)
	    : undefined;
	}

	/**
	 * Create Object containing input and input-related options.
	 * @private
	 */
	function _createInputDescriptor (input, inputOptions, containerOptions) {
	  const inputDescriptor = {
	    autoOrient: false,
	    failOn: 'warning',
	    limitInputPixels: 0x3FFF ** 2,
	    ignoreIcc: false,
	    unlimited: false,
	    sequentialRead: true
	  };
	  if (is.string(input)) {
	    // filesystem
	    inputDescriptor.file = input;
	  } else if (is.buffer(input)) {
	    // Buffer
	    if (input.length === 0) {
	      throw Error('Input Buffer is empty');
	    }
	    inputDescriptor.buffer = input;
	  } else if (is.arrayBuffer(input)) {
	    if (input.byteLength === 0) {
	      throw Error('Input bit Array is empty');
	    }
	    inputDescriptor.buffer = Buffer.from(input, 0, input.byteLength);
	  } else if (is.typedArray(input)) {
	    if (input.length === 0) {
	      throw Error('Input Bit Array is empty');
	    }
	    inputDescriptor.buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
	  } else if (is.plainObject(input) && !is.defined(inputOptions)) {
	    // Plain Object descriptor, e.g. create
	    inputOptions = input;
	    if (_inputOptionsFromObject(inputOptions)) {
	      // Stream with options
	      inputDescriptor.buffer = [];
	    }
	  } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
	    // Stream without options
	    inputDescriptor.buffer = [];
	  } else if (Array.isArray(input)) {
	    if (input.length > 1) {
	      // Join images together
	      if (!this.options.joining) {
	        this.options.joining = true;
	        this.options.join = input.map(i => this._createInputDescriptor(i));
	      } else {
	        throw new Error('Recursive join is unsupported');
	      }
	    } else {
	      throw new Error('Expected at least two images to join');
	    }
	  } else {
	    throw new Error(`Unsupported input '${input}' of type ${typeof input}${
	      is.defined(inputOptions) ? ` when also providing options of type ${typeof inputOptions}` : ''
	    }`);
	  }
	  if (is.object(inputOptions)) {
	    // Deprecated: failOnError
	    if (is.defined(inputOptions.failOnError)) {
	      if (is.bool(inputOptions.failOnError)) {
	        inputDescriptor.failOn = inputOptions.failOnError ? 'warning' : 'none';
	      } else {
	        throw is.invalidParameterError('failOnError', 'boolean', inputOptions.failOnError);
	      }
	    }
	    // failOn
	    if (is.defined(inputOptions.failOn)) {
	      if (is.string(inputOptions.failOn) && is.inArray(inputOptions.failOn, ['none', 'truncated', 'error', 'warning'])) {
	        inputDescriptor.failOn = inputOptions.failOn;
	      } else {
	        throw is.invalidParameterError('failOn', 'one of: none, truncated, error, warning', inputOptions.failOn);
	      }
	    }
	    // autoOrient
	    if (is.defined(inputOptions.autoOrient)) {
	      if (is.bool(inputOptions.autoOrient)) {
	        inputDescriptor.autoOrient = inputOptions.autoOrient;
	      } else {
	        throw is.invalidParameterError('autoOrient', 'boolean', inputOptions.autoOrient);
	      }
	    }
	    // Density
	    if (is.defined(inputOptions.density)) {
	      if (is.inRange(inputOptions.density, 1, 100000)) {
	        inputDescriptor.density = inputOptions.density;
	      } else {
	        throw is.invalidParameterError('density', 'number between 1 and 100000', inputOptions.density);
	      }
	    }
	    // Ignore embeddded ICC profile
	    if (is.defined(inputOptions.ignoreIcc)) {
	      if (is.bool(inputOptions.ignoreIcc)) {
	        inputDescriptor.ignoreIcc = inputOptions.ignoreIcc;
	      } else {
	        throw is.invalidParameterError('ignoreIcc', 'boolean', inputOptions.ignoreIcc);
	      }
	    }
	    // limitInputPixels
	    if (is.defined(inputOptions.limitInputPixels)) {
	      if (is.bool(inputOptions.limitInputPixels)) {
	        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels
	          ? 0x3FFF ** 2
	          : 0;
	      } else if (is.integer(inputOptions.limitInputPixels) && is.inRange(inputOptions.limitInputPixels, 0, Number.MAX_SAFE_INTEGER)) {
	        inputDescriptor.limitInputPixels = inputOptions.limitInputPixels;
	      } else {
	        throw is.invalidParameterError('limitInputPixels', 'positive integer', inputOptions.limitInputPixels);
	      }
	    }
	    // unlimited
	    if (is.defined(inputOptions.unlimited)) {
	      if (is.bool(inputOptions.unlimited)) {
	        inputDescriptor.unlimited = inputOptions.unlimited;
	      } else {
	        throw is.invalidParameterError('unlimited', 'boolean', inputOptions.unlimited);
	      }
	    }
	    // sequentialRead
	    if (is.defined(inputOptions.sequentialRead)) {
	      if (is.bool(inputOptions.sequentialRead)) {
	        inputDescriptor.sequentialRead = inputOptions.sequentialRead;
	      } else {
	        throw is.invalidParameterError('sequentialRead', 'boolean', inputOptions.sequentialRead);
	      }
	    }
	    // Raw pixel input
	    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.channels) && is.inRange(inputOptions.raw.channels, 1, 4)
	      ) {
	        inputDescriptor.rawWidth = inputOptions.raw.width;
	        inputDescriptor.rawHeight = inputOptions.raw.height;
	        inputDescriptor.rawChannels = inputOptions.raw.channels;
	        switch (input.constructor) {
	          case Uint8Array:
	          case Uint8ClampedArray:
	            inputDescriptor.rawDepth = 'uchar';
	            break;
	          case Int8Array:
	            inputDescriptor.rawDepth = 'char';
	            break;
	          case Uint16Array:
	            inputDescriptor.rawDepth = 'ushort';
	            break;
	          case Int16Array:
	            inputDescriptor.rawDepth = 'short';
	            break;
	          case Uint32Array:
	            inputDescriptor.rawDepth = 'uint';
	            break;
	          case Int32Array:
	            inputDescriptor.rawDepth = 'int';
	            break;
	          case Float32Array:
	            inputDescriptor.rawDepth = 'float';
	            break;
	          case Float64Array:
	            inputDescriptor.rawDepth = 'double';
	            break;
	          default:
	            inputDescriptor.rawDepth = 'uchar';
	            break;
	        }
	      } 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)) {
	      if (is.bool(inputOptions.animated)) {
	        inputDescriptor.pages = inputOptions.animated ? -1 : 1;
	      } else {
	        throw is.invalidParameterError('animated', 'boolean', inputOptions.animated);
	      }
	    }
	    if (is.defined(inputOptions.pages)) {
	      if (is.integer(inputOptions.pages) && is.inRange(inputOptions.pages, -1, 100000)) {
	        inputDescriptor.pages = inputOptions.pages;
	      } else {
	        throw is.invalidParameterError('pages', 'integer between -1 and 100000', inputOptions.pages);
	      }
	    }
	    if (is.defined(inputOptions.page)) {
	      if (is.integer(inputOptions.page) && is.inRange(inputOptions.page, 0, 100000)) {
	        inputDescriptor.page = inputOptions.page;
	      } else {
	        throw is.invalidParameterError('page', 'integer between 0 and 100000', inputOptions.page);
	      }
	    }
	    // 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.openSlideLevel = inputOptions.level;
	      } else {
	        throw is.invalidParameterError('level', 'integer between 0 and 256', inputOptions.level);
	      }
	    }
	    // 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.tiffSubifd = inputOptions.subifd;
	      } else {
	        throw is.invalidParameterError('subifd', 'integer between -1 and 100000', inputOptions.subifd);
	      }
	    }
	    // 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 (
	        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.channels)
	      ) {
	        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 (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.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);
	            }
	          }
	          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)) {
	            throw is.invalidParameterError('create.channels', 'number between 3 and 4', inputOptions.create.channels);
	          }
	          inputDescriptor.createBackground = this._getBackgroundColourOption(inputOptions.create.background);
	        } else {
	          throw new Error('Expected valid noise or background to create a new input image');
	        }
	        delete inputDescriptor.buffer;
	      } else {
	        throw new Error('Expected valid width, height and channels to create a new input image');
	      }
	    }
	    // Create a new image with text
	    if (is.defined(inputOptions.text)) {
	      if (is.object(inputOptions.text) && is.string(inputOptions.text.text)) {
	        inputDescriptor.textValue = inputOptions.text.text;
	        if (is.defined(inputOptions.text.height) && is.defined(inputOptions.text.dpi)) {
	          throw new Error('Expected only one of dpi or height');
	        }
	        if (is.defined(inputOptions.text.font)) {
	          if (is.string(inputOptions.text.font)) {
	            inputDescriptor.textFont = inputOptions.text.font;
	          } else {
	            throw is.invalidParameterError('text.font', 'string', inputOptions.text.font);
	          }
	        }
	        if (is.defined(inputOptions.text.fontfile)) {
	          if (is.string(inputOptions.text.fontfile)) {
	            inputDescriptor.textFontfile = inputOptions.text.fontfile;
	          } else {
	            throw is.invalidParameterError('text.fontfile', 'string', inputOptions.text.fontfile);
	          }
	        }
	        if (is.defined(inputOptions.text.width)) {
	          if (is.integer(inputOptions.text.width) && inputOptions.text.width > 0) {
	            inputDescriptor.textWidth = inputOptions.text.width;
	          } else {
	            throw is.invalidParameterError('text.width', 'positive integer', inputOptions.text.width);
	          }
	        }
	        if (is.defined(inputOptions.text.height)) {
	          if (is.integer(inputOptions.text.height) && inputOptions.text.height > 0) {
	            inputDescriptor.textHeight = inputOptions.text.height;
	          } else {
	            throw is.invalidParameterError('text.height', 'positive integer', inputOptions.text.height);
	          }
	        }
	        if (is.defined(inputOptions.text.align)) {
	          if (is.string(inputOptions.text.align) && is.string(this.constructor.align[inputOptions.text.align])) {
	            inputDescriptor.textAlign = this.constructor.align[inputOptions.text.align];
	          } else {
	            throw is.invalidParameterError('text.align', 'valid alignment', inputOptions.text.align);
	          }
	        }
	        if (is.defined(inputOptions.text.justify)) {
	          if (is.bool(inputOptions.text.justify)) {
	            inputDescriptor.textJustify = inputOptions.text.justify;
	          } else {
	            throw is.invalidParameterError('text.justify', 'boolean', inputOptions.text.justify);
	          }
	        }
	        if (is.defined(inputOptions.text.dpi)) {
	          if (is.integer(inputOptions.text.dpi) && is.inRange(inputOptions.text.dpi, 1, 1000000)) {
	            inputDescriptor.textDpi = inputOptions.text.dpi;
	          } else {
	            throw is.invalidParameterError('text.dpi', 'integer between 1 and 1000000', inputOptions.text.dpi);
	          }
	        }
	        if (is.defined(inputOptions.text.rgba)) {
	          if (is.bool(inputOptions.text.rgba)) {
	            inputDescriptor.textRgba = inputOptions.text.rgba;
	          } else {
	            throw is.invalidParameterError('text.rgba', 'bool', inputOptions.text.rgba);
	          }
	        }
	        if (is.defined(inputOptions.text.spacing)) {
	          if (is.integer(inputOptions.text.spacing) && is.inRange(inputOptions.text.spacing, -1e6, 1000000)) {
	            inputDescriptor.textSpacing = inputOptions.text.spacing;
	          } else {
	            throw is.invalidParameterError('text.spacing', 'integer between -1000000 and 1000000', inputOptions.text.spacing);
	          }
	        }
	        if (is.defined(inputOptions.text.wrap)) {
	          if (is.string(inputOptions.text.wrap) && is.inArray(inputOptions.text.wrap, ['word', 'char', 'word-char', 'none'])) {
	            inputDescriptor.textWrap = inputOptions.text.wrap;
	          } else {
	            throw is.invalidParameterError('text.wrap', 'one of: word, char, word-char, none', inputOptions.text.wrap);
	          }
	        }
	        delete inputDescriptor.buffer;
	      } else {
	        throw new Error('Expected a valid string to create an image with text.');
	      }
	    }
	    // Join images together
	    if (is.defined(inputOptions.join)) {
	      if (is.defined(this.options.join)) {
	        if (is.defined(inputOptions.join.animated)) {
	          if (is.bool(inputOptions.join.animated)) {
	            inputDescriptor.joinAnimated = inputOptions.join.animated;
	          } else {
	            throw is.invalidParameterError('join.animated', 'boolean', inputOptions.join.animated);
	          }
	        }
	        if (is.defined(inputOptions.join.across)) {
	          if (is.integer(inputOptions.join.across) && is.inRange(inputOptions.join.across, 1, 1000000)) {
	            inputDescriptor.joinAcross = inputOptions.join.across;
	          } else {
	            throw is.invalidParameterError('join.across', 'integer between 1 and 100000', inputOptions.join.across);
	          }
	        }
	        if (is.defined(inputOptions.join.shim)) {
	          if (is.integer(inputOptions.join.shim) && is.inRange(inputOptions.join.shim, 0, 1000000)) {
	            inputDescriptor.joinShim = inputOptions.join.shim;
	          } else {
	            throw is.invalidParameterError('join.shim', 'integer between 0 and 100000', inputOptions.join.shim);
	          }
	        }
	        if (is.defined(inputOptions.join.background)) {
	          inputDescriptor.joinBackground = this._getBackgroundColourOption(inputOptions.join.background);
	        }
	        if (is.defined(inputOptions.join.halign)) {
	          if (is.string(inputOptions.join.halign) && is.string(this.constructor.align[inputOptions.join.halign])) {
	            inputDescriptor.joinHalign = this.constructor.align[inputOptions.join.halign];
	          } else {
	            throw is.invalidParameterError('join.halign', 'valid alignment', inputOptions.join.halign);
	          }
	        }
	        if (is.defined(inputOptions.join.valign)) {
	          if (is.string(inputOptions.join.valign) && is.string(this.constructor.align[inputOptions.join.valign])) {
	            inputDescriptor.joinValign = this.constructor.align[inputOptions.join.valign];
	          } else {
	            throw is.invalidParameterError('join.valign', 'valid alignment', inputOptions.join.valign);
	          }
	        }
	      } else {
	        throw new Error('Expected input to be an array of images to join');
	      }
	    }
	  } else if (is.defined(inputOptions)) {
	    throw new Error(`Invalid input options ${inputOptions}`);
	  }
	  return inputDescriptor;
	}

	/**
	 * Handle incoming Buffer chunk on Writable Stream.
	 * @private
	 * @param {Buffer} chunk
	 * @param {string} encoding - unused
	 * @param {Function} callback
	 */
	function _write (chunk, _encoding, callback) {
	  if (Array.isArray(this.options.input.buffer)) {
	    if (is.buffer(chunk)) {
	      if (this.options.input.buffer.length === 0) {
	        this.on('finish', () => {
	          this.streamInFinished = true;
	        });
	      }
	      this.options.input.buffer.push(chunk);
	      callback();
	    } else {
	      callback(new Error('Non-Buffer data on Writable Stream'));
	    }
	  } else {
	    callback(new Error('Unexpected data on Writable Stream'));
	  }
	}

	/**
	 * Flattens the array of chunks accumulated in input.buffer.
	 * @private
	 */
	function _flattenBufferIn () {
	  if (this._isStreamInput()) {
	    this.options.input.buffer = Buffer.concat(this.options.input.buffer);
	  }
	}

	/**
	 * Are we expecting Stream-based input?
	 * @private
	 * @returns {boolean}
	 */
	function _isStreamInput () {
	  return Array.isArray(this.options.input.buffer);
	}

	/**
	 * Fast access to (uncached) image metadata without decoding any compressed pixel data.
	 *
	 * This is read from the header of the input image.
	 * It does not take into consideration any operations to be applied to the output image,
	 * such as resize or rotate.
	 *
	 * Dimensions in the response will respect the `page` and `pages` properties of the
	 * {@link /api-constructor/ constructor parameters}.
	 *
	 * A `Promise` is returned when `callback` is not provided.
	 *
	 * - `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
	 * - `size`: Total size of image in bytes, for Stream and Buffer input only
	 * - `width`: Number of pixels wide (EXIF orientation is not taken into consideration, see example below)
	 * - `height`: Number of pixels high (EXIF orientation is not taken into consideration, see example below)
	 * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://www.libvips.org/API/current/enum.Interpretation.html)
	 * - `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
	 * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://www.libvips.org/API/current/enum.BandFormat.html)
	 * - `density`: Number of pixels per inch (DPI), if present
	 * - `chromaSubsampling`: 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
	 * - `isProgressive`: Boolean indicating whether the image is interlaced using a progressive scan
	 * - `isPalette`: Boolean indicating whether the image is palette-based (GIF, PNG).
	 * - `bitsPerSample`: Number of bits per sample for each channel (GIF, PNG, HEIF).
	 * - `pages`: Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP
	 * - `pageHeight`: Number of pixels high each page in a multi-page image will be.
	 * - `loop`: Number of times to loop an animated image, zero refers to a continuous loop.
	 * - `delay`: Delay in ms between each page in an animated image, provided as an array of integers.
	 * - `pagePrimary`: Number of the primary page in a HEIF image
	 * - `levels`: Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide
	 * - `subifds`: Number of Sub Image File Directories in an OME-TIFF image
	 * - `background`: Default background colour, if present, for PNG (bKGD) and GIF images
	 * - `compression`: The encoder used to compress an HEIF file, `av1` (AVIF) or `hevc` (HEIC)
	 * - `resolutionUnit`: The unit of resolution (density), either `inch` or `cm`, if present
	 * - `hasProfile`: Boolean indicating the presence of an embedded ICC profile
	 * - `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
	 * - `orientation`: Number value of the EXIF Orientation header, if present
	 * - `exif`: Buffer containing raw EXIF data, if present
	 * - `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.
	 *
	 * @example
	 * const metadata = await sharp(input).metadata();
	 *
	 * @example
	 * const image = sharp(inputJpg);
	 * image
	 *   .metadata()
	 *   .then(function(metadata) {
	 *     return image
	 *       .resize(Math.round(metadata.width / 2))
	 *       .webp()
	 *       .toBuffer();
	 *   })
	 *   .then(function(data) {
	 *     // data contains a WebP image half the width and height of the original JPEG
	 *   });
	 *
	 * @example
	 * // Get dimensions taking EXIF Orientation into account.
	 * const { autoOrient } = await sharp(input).metadata();
	 * const { width, height } = autoOrient;
	 *
	 * @param {Function} [callback] - called with the arguments `(err, metadata)`
	 * @returns {Promise<Object>|Sharp}
	 */
	function metadata (callback) {
	  const stack = Error();
	  if (is.fn(callback)) {
	    if (this._isStreamInput()) {
	      this.on('finish', () => {
	        this._flattenBufferIn();
	        sharp.metadata(this.options, (err, metadata) => {
	          if (err) {
	            callback(is.nativeError(err, stack));
	          } else {
	            callback(null, metadata);
	          }
	        });
	      });
	    } else {
	      sharp.metadata(this.options, (err, metadata) => {
	        if (err) {
	          callback(is.nativeError(err, stack));
	        } else {
	          callback(null, metadata);
	        }
	      });
	    }
	    return this;
	  } else {
	    if (this._isStreamInput()) {
	      return new Promise((resolve, reject) => {
	        const finished = () => {
	          this._flattenBufferIn();
	          sharp.metadata(this.options, (err, metadata) => {
	            if (err) {
	              reject(is.nativeError(err, stack));
	            } else {
	              resolve(metadata);
	            }
	          });
	        };
	        if (this.writableFinished) {
	          finished();
	        } else {
	          this.once('finish', finished);
	        }
	      });
	    } else {
	      return new Promise((resolve, reject) => {
	        sharp.metadata(this.options, (err, metadata) => {
	          if (err) {
	            reject(is.nativeError(err, stack));
	          } else {
	            resolve(metadata);
	          }
	        });
	      });
	    }
	  }
	}

	/**
	 * Access to pixel-derived image statistics for every channel in the image.
	 * A `Promise` is returned when `callback` is not provided.
	 *
	 * - `channels`: Array of channel statistics for each channel in the image. Each channel statistic contains
	 *     - `min` (minimum value in the channel)
	 *     - `max` (maximum value in the channel)
	 *     - `sum` (sum of all values in a channel)
	 *     - `squaresSum` (sum of squared values in a channel)
	 *     - `mean` (mean of the values in a channel)
	 *     - `stdev` (standard deviation for the values in a channel)
	 *     - `minX` (x-coordinate of one of the pixel where the minimum lies)
	 *     - `minY` (y-coordinate of one of the pixel where the minimum lies)
	 *     - `maxX` (x-coordinate of one of the pixel where the maximum lies)
	 *     - `maxY` (y-coordinate of one of the pixel where the maximum lies)
	 * - `isOpaque`: Is the image fully opaque? Will be `true` if the image has no alpha channel or if every pixel is fully opaque.
	 * - `entropy`: Histogram-based estimation of greyscale entropy, discarding alpha channel if any.
	 * - `sharpness`: Estimation of greyscale sharpness based on the standard deviation of a Laplacian convolution, discarding alpha channel if any.
	 * - `dominant`: Object containing most dominant sRGB colour based on a 4096-bin 3D histogram.
	 *
	 * **Note**: Statistics are derived from the original input image. Any operations performed on the image must first be
	 * written to a buffer in order to run `stats` on the result (see third example).
	 *
	 * @example
	 * const image = sharp(inputJpg);
	 * image
	 *   .stats()
	 *   .then(function(stats) {
	 *      // stats contains the channel-wise statistics array and the isOpaque value
	 *   });
	 *
	 * @example
	 * const { entropy, sharpness, dominant } = await sharp(input).stats();
	 * const { r, g, b } = dominant;
	 *
	 * @example
	 * const image = sharp(input);
	 * // store intermediate result
	 * const part = await image.extract(region).toBuffer();
	 * // create new instance to obtain statistics of extracted region
	 * const stats = await sharp(part).stats();
	 *
	 * @param {Function} [callback] - called with the arguments `(err, stats)`
	 * @returns {Promise<Object>}
	 */
	function stats (callback) {
	  const stack = Error();
	  if (is.fn(callback)) {
	    if (this._isStreamInput()) {
	      this.on('finish', () => {
	        this._flattenBufferIn();
	        sharp.stats(this.options, (err, stats) => {
	          if (err) {
	            callback(is.nativeError(err, stack));
	          } else {
	            callback(null, stats);
	          }
	        });
	      });
	    } else {
	      sharp.stats(this.options, (err, stats) => {
	        if (err) {
	          callback(is.nativeError(err, stack));
	        } else {
	          callback(null, stats);
	        }
	      });
	    }
	    return this;
	  } else {
	    if (this._isStreamInput()) {
	      return new Promise((resolve, reject) => {
	        this.on('finish', function () {
	          this._flattenBufferIn();
	          sharp.stats(this.options, (err, stats) => {
	            if (err) {
	              reject(is.nativeError(err, stack));
	            } else {
	              resolve(stats);
	            }
	          });
	        });
	      });
	    } else {
	      return new Promise((resolve, reject) => {
	        sharp.stats(this.options, (err, stats) => {
	          if (err) {
	            reject(is.nativeError(err, stack));
	          } else {
	            resolve(stats);
	          }
	        });
	      });
	    }
	  }
	}

	/**
	 * Decorate the Sharp prototype with input-related functions.
	 * @module Sharp
	 * @private
	 */
	input = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    // Private
	    _inputOptionsFromObject,
	    _createInputDescriptor,
	    _write,
	    _flattenBufferIn,
	    _isStreamInput,
	    // Public
	    metadata,
	    stats
	  });
	  // Class attributes
	  Sharp.align = align;
	};
	return input;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var resize_1;
var hasRequiredResize;

function requireResize () {
	if (hasRequiredResize) return resize_1;
	hasRequiredResize = 1;
	const is = requireIs();

	/**
	 * Weighting to apply when using contain/cover fit.
	 * @member
	 * @private
	 */
	const gravity = {
	  center: 0,
	  centre: 0,
	  north: 1,
	  east: 2,
	  south: 3,
	  west: 4,
	  northeast: 5,
	  southeast: 6,
	  southwest: 7,
	  northwest: 8
	};

	/**
	 * Position to apply when using contain/cover fit.
	 * @member
	 * @private
	 */
	const position = {
	  top: 1,
	  right: 2,
	  bottom: 3,
	  left: 4,
	  'right top': 5,
	  'right bottom': 6,
	  'left bottom': 7,
	  'left top': 8
	};

	/**
	 * How to extend the image.
	 * @member
	 * @private
	 */
	const extendWith = {
	  background: 'background',
	  copy: 'copy',
	  repeat: 'repeat',
	  mirror: 'mirror'
	};

	/**
	 * Strategies for automagic cover behaviour.
	 * @member
	 * @private
	 */
	const strategy = {
	  entropy: 16,
	  attention: 17
	};

	/**
	 * Reduction kernels.
	 * @member
	 * @private
	 */
	const kernel = {
	  nearest: 'nearest',
	  linear: 'linear',
	  cubic: 'cubic',
	  mitchell: 'mitchell',
	  lanczos2: 'lanczos2',
	  lanczos3: 'lanczos3',
	  mks2013: 'mks2013',
	  mks2021: 'mks2021'
	};

	/**
	 * Methods by which an image can be resized to fit the provided dimensions.
	 * @member
	 * @private
	 */
	const fit = {
	  contain: 'contain',
	  cover: 'cover',
	  fill: 'fill',
	  inside: 'inside',
	  outside: 'outside'
	};

	/**
	 * Map external fit property to internal canvas property.
	 * @member
	 * @private
	 */
	const mapFitToCanvas = {
	  contain: 'embed',
	  cover: 'crop',
	  fill: 'ignore_aspect',
	  inside: 'max',
	  outside: 'min'
	};

	/**
	 * @private
	 */
	function isRotationExpected (options) {
	  return (options.angle % 360) !== 0 || options.rotationAngle !== 0;
	}

	/**
	 * @private
	 */
	function isResizeExpected (options) {
	  return options.width !== -1 || options.height !== -1;
	}

	/**
	 * Resize image to `width`, `height` or `width x height`.
	 *
	 * When both a `width` and `height` are provided, the possible methods by which the image should **fit** these are:
	 * - `cover`: (default) Preserving aspect ratio, attempt to ensure the image covers both provided dimensions by cropping/clipping to fit.
	 * - `contain`: Preserving aspect ratio, contain within both provided dimensions using "letterboxing" where necessary.
	 * - `fill`: Ignore the aspect ratio of the input and stretch to both provided dimensions.
	 * - `inside`: Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to both those specified.
	 * - `outside`: Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to both those specified.
	 *
	 * Some of these values are based on the [object-fit](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) CSS property.
	 *
	 * <img alt="Examples of various values for the fit property when resizing" width="100%" style="aspect-ratio: 998/243" src="/api-resize-fit.svg">
	 *
	 * When using a **fit** of `cover` or `contain`, the default **position** is `centre`. Other options are:
	 * - `sharp.position`: `top`, `right top`, `right`, `right bottom`, `bottom`, `left bottom`, `left`, `left top`.
	 * - `sharp.gravity`: `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` or `centre`.
	 * - `sharp.strategy`: `cover` only, dynamically crop using either the `entropy` or `attention` strategy.
	 *
	 * Some of these values are based on the [object-position](https://developer.mozilla.org/en-US/docs/Web/CSS/object-position) CSS property.
	 *
	 * The strategy-based approach initially resizes so one dimension is at its target length
	 * then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
	 * - `entropy`: focus on the region with the highest [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29).
	 * - `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
	 *
	 * Possible downsizing kernels are:
	 * - `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
	 * - `linear`: Use a [triangle filter](https://en.wikipedia.org/wiki/Triangular_function).
	 * - `cubic`: Use a [Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline).
	 * - `mitchell`: Use a [Mitchell-Netravali spline](https://www.cs.utexas.edu/~fussell/courses/cs384g-fall2013/lectures/mitchell/Mitchell.pdf).
	 * - `lanczos2`: Use a [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel) with `a=2`.
	 * - `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
	 * - `mks2013`: Use a [Magic Kernel Sharp](https://johncostella.com/magic/mks.pdf) 2013 kernel, as adopted by Facebook.
	 * - `mks2021`: Use a Magic Kernel Sharp 2021 kernel, with more accurate (reduced) sharpening than the 2013 version.
	 *
	 * When upsampling, these kernels map to `nearest`, `linear` and `cubic` interpolators.
	 * Downsampling kernels without a matching upsampling interpolator map to `cubic`.
	 *
	 * Only one resize can occur per pipeline.
	 * Previous calls to `resize` in the same pipeline will be ignored.
	 *
	 * @example
	 * sharp(input)
	 *   .resize({ width: 100 })
	 *   .toBuffer()
	 *   .then(data => {
	 *     // 100 pixels wide, auto-scaled height
	 *   });
	 *
	 * @example
	 * sharp(input)
	 *   .resize({ height: 100 })
	 *   .toBuffer()
	 *   .then(data => {
	 *     // 100 pixels high, auto-scaled width
	 *   });
	 *
	 * @example
	 * sharp(input)
	 *   .resize(200, 300, {
	 *     kernel: sharp.kernel.nearest,
	 *     fit: 'contain',
	 *     position: 'right top',
	 *     background: { r: 255, g: 255, b: 255, alpha: 0.5 }
	 *   })
	 *   .toFile('output.png')
	 *   .then(() => {
	 *     // output.png is a 200 pixels wide and 300 pixels high image
	 *     // containing a nearest-neighbour scaled version
	 *     // contained within the north-east corner of a semi-transparent white canvas
	 *   });
	 *
	 * @example
	 * const transformer = sharp()
	 *   .resize({
	 *     width: 200,
	 *     height: 200,
	 *     fit: sharp.fit.cover,
	 *     position: sharp.strategy.entropy
	 *   });
	 * // Read image data from readableStream
	 * // Write 200px square auto-cropped image data to writableStream
	 * readableStream
	 *   .pipe(transformer)
	 *   .pipe(writableStream);
	 *
	 * @example
	 * sharp(input)
	 *   .resize(200, 200, {
	 *     fit: sharp.fit.inside,
	 *     withoutEnlargement: true
	 *   })
	 *   .toFormat('jpeg')
	 *   .toBuffer()
	 *   .then(function(outputBuffer) {
	 *     // outputBuffer contains JPEG image data
	 *     // no wider and no higher than 200 pixels
	 *     // and no larger than the input image
	 *   });
	 *
	 * @example
	 * sharp(input)
	 *   .resize(200, 200, {
	 *     fit: sharp.fit.outside,
	 *     withoutReduction: true
	 *   })
	 *   .toFormat('jpeg')
	 *   .toBuffer()
	 *   .then(function(outputBuffer) {
	 *     // outputBuffer contains JPEG image data
	 *     // of at least 200 pixels wide and 200 pixels high while maintaining aspect ratio
	 *     // and no smaller than the input image
	 *   });
	 *
	 * @example
	 * const scaleByHalf = await sharp(input)
	 *   .metadata()
	 *   .then(({ width }) => sharp(input)
	 *     .resize(Math.round(width * 0.5))
	 *     .toBuffer()
	 *   );
	 *
	 * @param {number} [width] - How many pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
	 * @param {number} [height] - How many pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
	 * @param {Object} [options]
	 * @param {number} [options.width] - An alternative means of specifying `width`. If both are present this takes priority.
	 * @param {number} [options.height] - An alternative means of specifying `height`. If both are present this takes priority.
	 * @param {String} [options.fit='cover'] - How the image should be resized/cropped to fit the target dimension(s), one of `cover`, `contain`, `fill`, `inside` or `outside`.
	 * @param {String} [options.position='centre'] - A position, gravity or strategy to use when `fit` is `cover` or `contain`.
	 * @param {String|Object} [options.background={r: 0, g: 0, b: 0, alpha: 1}] - background colour when `fit` is `contain`, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black without transparency.
	 * @param {String} [options.kernel='lanczos3'] - The kernel to use for image reduction and the inferred interpolator to use for upsampling. Use the `fastShrinkOnLoad` option to control kernel vs shrink-on-load.
	 * @param {Boolean} [options.withoutEnlargement=false] - Do not scale up if the width *or* height are already less than the target dimensions, equivalent to GraphicsMagick's `>` geometry option. This may result in output dimensions smaller than the target dimensions.
	 * @param {Boolean} [options.withoutReduction=false] - Do not scale down if the width *or* height are already greater than the target dimensions, equivalent to GraphicsMagick's `<` geometry option. This may still result in a crop to reach the target dimensions.
	 * @param {Boolean} [options.fastShrinkOnLoad=true] - Take greater advantage of the JPEG and WebP shrink-on-load feature, which can lead to a slight moiré pattern or round-down of an auto-scaled dimension.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function resize (widthOrOptions, height, options) {
	  if (isResizeExpected(this.options)) {
	    this.options.debuglog('ignoring previous resize options');
	  }
	  if (this.options.widthPost !== -1) {
	    this.options.debuglog('operation order will be: extract, resize, extract');
	  }
	  if (is.defined(widthOrOptions)) {
	    if (is.object(widthOrOptions) && !is.defined(options)) {
	      options = widthOrOptions;
	    } else if (is.integer(widthOrOptions) && widthOrOptions > 0) {
	      this.options.width = widthOrOptions;
	    } else {
	      throw is.invalidParameterError('width', 'positive integer', widthOrOptions);
	    }
	  } else {
	    this.options.width = -1;
	  }
	  if (is.defined(height)) {
	    if (is.integer(height) && height > 0) {
	      this.options.height = height;
	    } else {
	      throw is.invalidParameterError('height', 'positive integer', height);
	    }
	  } else {
	    this.options.height = -1;
	  }
	  if (is.object(options)) {
	    // Width
	    if (is.defined(options.width)) {
	      if (is.integer(options.width) && options.width > 0) {
	        this.options.width = options.width;
	      } else {
	        throw is.invalidParameterError('width', 'positive integer', options.width);
	      }
	    }
	    // Height
	    if (is.defined(options.height)) {
	      if (is.integer(options.height) && options.height > 0) {
	        this.options.height = options.height;
	      } else {
	        throw is.invalidParameterError('height', 'positive integer', options.height);
	      }
	    }
	    // Fit
	    if (is.defined(options.fit)) {
	      const canvas = mapFitToCanvas[options.fit];
	      if (is.string(canvas)) {
	        this.options.canvas = canvas;
	      } else {
	        throw is.invalidParameterError('fit', 'valid fit', options.fit);
	      }
	    }
	    // Position
	    if (is.defined(options.position)) {
	      const pos = is.integer(options.position)
	        ? options.position
	        : strategy[options.position] || position[options.position] || gravity[options.position];
	      if (is.integer(pos) && (is.inRange(pos, 0, 8) || is.inRange(pos, 16, 17))) {
	        this.options.position = pos;
	      } else {
	        throw is.invalidParameterError('position', 'valid position/gravity/strategy', options.position);
	      }
	    }
	    // Background
	    this._setBackgroundColourOption('resizeBackground', options.background);
	    // Kernel
	    if (is.defined(options.kernel)) {
	      if (is.string(kernel[options.kernel])) {
	        this.options.kernel = kernel[options.kernel];
	      } else {
	        throw is.invalidParameterError('kernel', 'valid kernel name', options.kernel);
	      }
	    }
	    // Without enlargement
	    if (is.defined(options.withoutEnlargement)) {
	      this._setBooleanOption('withoutEnlargement', options.withoutEnlargement);
	    }
	    // Without reduction
	    if (is.defined(options.withoutReduction)) {
	      this._setBooleanOption('withoutReduction', options.withoutReduction);
	    }
	    // Shrink on load
	    if (is.defined(options.fastShrinkOnLoad)) {
	      this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);
	    }
	  }
	  if (isRotationExpected(this.options) && isResizeExpected(this.options)) {
	    this.options.rotateBefore = true;
	  }
	  return this;
	}

	/**
	 * Extend / pad / extrude one or more edges of the image with either
	 * the provided background colour or pixels derived from the image.
	 * This operation will always occur after resizing and extraction, if any.
	 *
	 * @example
	 * // Resize to 140 pixels wide, then add 10 transparent pixels
	 * // to the top, left and right edges and 20 to the bottom edge
	 * sharp(input)
	 *   .resize(140)
	 *   .extend({
	 *     top: 10,
	 *     bottom: 20,
	 *     left: 10,
	 *     right: 10,
	 *     background: { r: 0, g: 0, b: 0, alpha: 0 }
	 *   })
	 *   ...
	 *
	* @example
	 * // Add a row of 10 red pixels to the bottom
	 * sharp(input)
	 *   .extend({
	 *     bottom: 10,
	 *     background: 'red'
	 *   })
	 *   ...
	 *
	 * @example
	 * // Extrude image by 8 pixels to the right, mirroring existing right hand edge
	 * sharp(input)
	 *   .extend({
	 *     right: 8,
	 *     background: 'mirror'
	 *   })
	 *   ...
	 *
	 * @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 {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;
	  } else if (is.object(extend)) {
	    if (is.defined(extend.top)) {
	      if (is.integer(extend.top) && extend.top >= 0) {
	        this.options.extendTop = extend.top;
	      } else {
	        throw is.invalidParameterError('top', 'positive integer', extend.top);
	      }
	    }
	    if (is.defined(extend.bottom)) {
	      if (is.integer(extend.bottom) && extend.bottom >= 0) {
	        this.options.extendBottom = extend.bottom;
	      } else {
	        throw is.invalidParameterError('bottom', 'positive integer', extend.bottom);
	      }
	    }
	    if (is.defined(extend.left)) {
	      if (is.integer(extend.left) && extend.left >= 0) {
	        this.options.extendLeft = extend.left;
	      } else {
	        throw is.invalidParameterError('left', 'positive integer', extend.left);
	      }
	    }
	    if (is.defined(extend.right)) {
	      if (is.integer(extend.right) && extend.right >= 0) {
	        this.options.extendRight = extend.right;
	      } else {
	        throw is.invalidParameterError('right', 'positive integer', extend.right);
	      }
	    }
	    this._setBackgroundColourOption('extendBackground', extend.background);
	    if (is.defined(extend.extendWith)) {
	      if (is.string(extendWith[extend.extendWith])) {
	        this.options.extendWith = extendWith[extend.extendWith];
	      } else {
	        throw is.invalidParameterError('extendWith', 'one of: background, copy, repeat, mirror', extend.extendWith);
	      }
	    }
	  } else {
	    throw is.invalidParameterError('extend', 'integer or object', extend);
	  }
	  return this;
	}

	/**
	 * Extract/crop a region of the image.
	 *
	 * - Use `extract` before `resize` for pre-resize extraction.
	 * - Use `extract` after `resize` for post-resize extraction.
	 * - Use `extract` twice and `resize` once for extract-then-resize-then-extract in a fixed operation order.
	 *
	 * @example
	 * sharp(input)
	 *   .extract({ left: left, top: top, width: width, height: height })
	 *   .toFile(output, function(err) {
	 *     // Extract a region of the input image, saving in the same format.
	 *   });
	 * @example
	 * sharp(input)
	 *   .extract({ left: leftOffsetPre, top: topOffsetPre, width: widthPre, height: heightPre })
	 *   .resize(width, height)
	 *   .extract({ left: leftOffsetPost, top: topOffsetPost, width: widthPost, height: heightPost })
	 *   .toFile(output, function(err) {
	 *     // Extract a region, resize, then extract from the resized image
	 *   });
	 *
	 * @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
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function extract (options) {
	  const suffix = isResizeExpected(this.options) || this.options.widthPre !== -1 ? 'Post' : 'Pre';
	  if (this.options[`width${suffix}`] !== -1) {
	    this.options.debuglog('ignoring previous extract options');
	  }
	  ['left', 'top', 'width', 'height'].forEach(function (name) {
	    const value = options[name];
	    if (is.integer(value) && value >= 0) {
	      this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
	    } else {
	      throw is.invalidParameterError(name, 'integer', value);
	    }
	  }, this);
	  // Ensure existing rotation occurs before pre-resize extraction
	  if (isRotationExpected(this.options) && !isResizeExpected(this.options)) {
	    if (this.options.widthPre === -1 || this.options.widthPost === -1) {
	      this.options.rotateBefore = true;
	    }
	  }
	  if (this.options.input.autoOrient) {
	    this.options.orientBefore = true;
	  }
	  return this;
	}

	/**
	 * Trim pixels from all edges that contain values similar to the given background colour, which defaults to that of the top-left pixel.
	 *
	 * Images with an alpha channel will use the combined bounding box of alpha and non-alpha channels.
	 *
	 * If the result of this operation would trim an image to nothing then no change is made.
	 *
	 * The `info` response Object will contain `trimOffsetLeft` and `trimOffsetTop` properties.
	 *
	 * @example
	 * // Trim pixels with a colour similar to that of the top-left pixel.
	 * await sharp(input)
	 *   .trim()
	 *   .toFile(output);
	 *
	 * @example
	 * // Trim pixels with the exact same colour as that of the top-left pixel.
	 * await sharp(input)
	 *   .trim({
	 *     threshold: 0
	 *   })
	 *   .toFile(output);
	 *
	 * @example
	 * // Assume input is line art and trim only pixels with a similar colour to red.
	 * const output = await sharp(input)
	 *   .trim({
	 *     background: "#FF0000",
	 *     lineArt: true
	 *   })
	 *   .toBuffer();
	 *
	 * @example
	 * // Trim all "yellow-ish" pixels, being more lenient with the higher threshold.
	 * const output = await sharp(input)
	 *   .trim({
	 *     background: "yellow",
	 *     threshold: 42,
	 *   })
	 *   .toBuffer();
	 *
	 * @param {Object} [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?
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function trim (options) {
	  this.options.trimThreshold = 10;
	  if (is.defined(options)) {
	    if (is.object(options)) {
	      if (is.defined(options.background)) {
	        this._setBackgroundColourOption('trimBackground', options.background);
	      }
	      if (is.defined(options.threshold)) {
	        if (is.number(options.threshold) && options.threshold >= 0) {
	          this.options.trimThreshold = options.threshold;
	        } else {
	          throw is.invalidParameterError('threshold', 'positive number', options.threshold);
	        }
	      }
	      if (is.defined(options.lineArt)) {
	        this._setBooleanOption('trimLineArt', options.lineArt);
	      }
	    } else {
	      throw is.invalidParameterError('trim', 'object', options);
	    }
	  }
	  if (isRotationExpected(this.options)) {
	    this.options.rotateBefore = true;
	  }
	  return this;
	}

	/**
	 * Decorate the Sharp prototype with resize-related functions.
	 * @module Sharp
	 * @private
	 */
	resize_1 = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    resize,
	    extend,
	    extract,
	    trim
	  });
	  // Class attributes
	  Sharp.gravity = gravity;
	  Sharp.strategy = strategy;
	  Sharp.kernel = kernel;
	  Sharp.fit = fit;
	  Sharp.position = position;
	};
	return resize_1;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var composite_1;
var hasRequiredComposite;

function requireComposite () {
	if (hasRequiredComposite) return composite_1;
	hasRequiredComposite = 1;
	const is = requireIs();

	/**
	 * Blend modes.
	 * @member
	 * @private
	 */
	const blend = {
	  clear: 'clear',
	  source: 'source',
	  over: 'over',
	  in: 'in',
	  out: 'out',
	  atop: 'atop',
	  dest: 'dest',
	  'dest-over': 'dest-over',
	  'dest-in': 'dest-in',
	  'dest-out': 'dest-out',
	  'dest-atop': 'dest-atop',
	  xor: 'xor',
	  add: 'add',
	  saturate: 'saturate',
	  multiply: 'multiply',
	  screen: 'screen',
	  overlay: 'overlay',
	  darken: 'darken',
	  lighten: 'lighten',
	  'colour-dodge': 'colour-dodge',
	  'color-dodge': 'colour-dodge',
	  'colour-burn': 'colour-burn',
	  'color-burn': 'colour-burn',
	  'hard-light': 'hard-light',
	  'soft-light': 'soft-light',
	  difference: 'difference',
	  exclusion: 'exclusion'
	};

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

	/**
	 * Decorate the Sharp prototype with composite-related functions.
	 * @module Sharp
	 * @private
	 */
	composite_1 = (Sharp) => {
	  Sharp.prototype.composite = composite;
	  Sharp.blend = blend;
	};
	return composite_1;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var operation;
var hasRequiredOperation;

function requireOperation () {
	if (hasRequiredOperation) return operation;
	hasRequiredOperation = 1;
	const is = requireIs();

	/**
	 * How accurate an operation should be.
	 * @member
	 * @private
	 */
	const vipsPrecision = {
	  integer: 'integer',
	  float: 'float',
	  approximate: 'approximate'
	};

	/**
	 * Rotate the output image.
	 *
	 * The provided angle is converted to a valid positive degree rotation.
	 * For example, `-450` will produce a 270 degree rotation.
	 *
	 * When rotating by an angle other than a multiple of 90,
	 * the background colour can be provided with the `background` option.
	 *
	 * For backwards compatibility, if no angle is provided, `.autoOrient()` will be called.
	 *
	 * Only one rotation can occur per pipeline (aside from an initial call without
	 * arguments to orient via EXIF data). Previous calls to `rotate` in the same
	 * pipeline will be ignored.
	 *
	 * Multi-page images can only be rotated by 180 degrees.
	 *
	 * Method order is important when rotating, resizing and/or extracting regions,
	 * for example `.rotate(x).extract(y)` will produce a different result to `.extract(y).rotate(x)`.
	 *
	 * @example
	 * const rotateThenResize = await sharp(input)
	 *   .rotate(90)
	 *   .resize({ width: 16, height: 8, fit: 'fill' })
	 *   .toBuffer();
	 * const resizeThenRotate = await sharp(input)
	 *   .resize({ width: 16, height: 8, fit: 'fill' })
	 *   .rotate(90)
	 *   .toBuffer();
	 *
	 * @param {number} [angle=auto] angle of rotation.
	 * @param {Object} [options] - if present, is an Object with optional attributes.
	 * @param {string|Object} [options.background="#000000"] parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function rotate (angle, options) {
	  if (!is.defined(angle)) {
	    return this.autoOrient();
	  }
	  if (this.options.angle || this.options.rotationAngle) {
	    this.options.debuglog('ignoring previous rotate options');
	    this.options.angle = 0;
	    this.options.rotationAngle = 0;
	  }
	  if (is.integer(angle) && !(angle % 90)) {
	    this.options.angle = angle;
	  } else if (is.number(angle)) {
	    this.options.rotationAngle = angle;
	    if (is.object(options) && options.background) {
	      this._setBackgroundColourOption('rotationBackground', options.background);
	    }
	  } else {
	    throw is.invalidParameterError('angle', 'numeric', angle);
	  }
	  return this;
	}

	/**
	 * Auto-orient based on the EXIF `Orientation` tag, then remove the tag.
	 * Mirroring is supported and may infer the use of a flip operation.
	 *
	 * Previous or subsequent use of `rotate(angle)` and either `flip()` or `flop()`
	 * will logically occur after auto-orientation, regardless of call order.
	 *
	 * @example
	 * const output = await sharp(input).autoOrient().toBuffer();
	 *
	 * @example
	 * const pipeline = sharp()
	 *   .autoOrient()
	 *   .resize(null, 200)
	 *   .toBuffer(function (err, outputBuffer, info) {
	 *     // outputBuffer contains 200px high JPEG image data,
	 *     // auto-oriented using EXIF Orientation tag
	 *     // info.width and info.height contain the dimensions of the resized image
	 *   });
	 * readableStream.pipe(pipeline);
	 *
	 * @returns {Sharp}
	 */
	function autoOrient () {
	  this.options.input.autoOrient = true;
	  return this;
	}

	/**
	 * Mirror the image vertically (up-down) about the x-axis.
	 * This always occurs before rotation, if any.
	 *
	 * This operation does not work correctly with multi-page images.
	 *
	 * @example
	 * const output = await sharp(input).flip().toBuffer();
	 *
	 * @param {Boolean} [flip=true]
	 * @returns {Sharp}
	 */
	function flip (flip) {
	  this.options.flip = is.bool(flip) ? flip : true;
	  return this;
	}

	/**
	 * Mirror the image horizontally (left-right) about the y-axis.
	 * This always occurs before rotation, if any.
	 *
	 * @example
	 * const output = await sharp(input).flop().toBuffer();
	 *
	 * @param {Boolean} [flop=true]
	 * @returns {Sharp}
	 */
	function flop (flop) {
	  this.options.flop = is.bool(flop) ? flop : true;
	  return this;
	}

	/**
	 * Perform an affine transform on an image. This operation will always occur after resizing, extraction and rotation, if any.
	 *
	 * You must provide an array of length 4 or a 2x2 affine transformation matrix.
	 * By default, new pixels are filled with a black background. You can provide a background colour with the `background` option.
	 * A particular interpolator may also be specified. Set the `interpolator` option to an attribute of the `sharp.interpolators` Object e.g. `sharp.interpolators.nohalo`.
	 *
	 * In the case of a 2x2 matrix, the transform is:
	 * - X = `matrix[0, 0]` \* (x + `idx`) + `matrix[0, 1]` \* (y + `idy`) + `odx`
	 * - Y = `matrix[1, 0]` \* (x + `idx`) + `matrix[1, 1]` \* (y + `idy`) + `ody`
	 *
	 * where:
	 * - x and y are the coordinates in input image.
	 * - X and Y are the coordinates in output image.
	 * - (0,0) is the upper left corner.
	 *
	 * @since 0.27.0
	 *
	 * @example
	 * const pipeline = sharp()
	 *   .affine([[1, 0.3], [0.1, 0.7]], {
	 *      background: 'white',
	 *      interpolator: sharp.interpolators.nohalo
	 *   })
	 *   .toBuffer((err, outputBuffer, info) => {
	 *      // outputBuffer contains the transformed image
	 *      // info.width and info.height contain the new dimensions
	 *   });
	 *
	 * inputStream
	 *   .pipe(pipeline);
	 *
	 * @param {Array<Array<number>>|Array<number>} matrix - affine transformation matrix
	 * @param {Object} [options] - if present, is an Object with optional attributes.
	 * @param {String|Object} [options.background="#000000"] - parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
	 * @param {Number} [options.idx=0] - input horizontal offset
	 * @param {Number} [options.idy=0] - input vertical offset
	 * @param {Number} [options.odx=0] - output horizontal offset
	 * @param {Number} [options.ody=0] - output vertical offset
	 * @param {String} [options.interpolator=sharp.interpolators.bicubic] - interpolator
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function affine (matrix, options) {
	  const flatMatrix = [].concat(...matrix);
	  if (flatMatrix.length === 4 && flatMatrix.every(is.number)) {
	    this.options.affineMatrix = flatMatrix;
	  } else {
	    throw is.invalidParameterError('matrix', '1x4 or 2x2 array', matrix);
	  }

	  if (is.defined(options)) {
	    if (is.object(options)) {
	      this._setBackgroundColourOption('affineBackground', options.background);
	      if (is.defined(options.idx)) {
	        if (is.number(options.idx)) {
	          this.options.affineIdx = options.idx;
	        } else {
	          throw is.invalidParameterError('options.idx', 'number', options.idx);
	        }
	      }
	      if (is.defined(options.idy)) {
	        if (is.number(options.idy)) {
	          this.options.affineIdy = options.idy;
	        } else {
	          throw is.invalidParameterError('options.idy', 'number', options.idy);
	        }
	      }
	      if (is.defined(options.odx)) {
	        if (is.number(options.odx)) {
	          this.options.affineOdx = options.odx;
	        } else {
	          throw is.invalidParameterError('options.odx', 'number', options.odx);
	        }
	      }
	      if (is.defined(options.ody)) {
	        if (is.number(options.ody)) {
	          this.options.affineOdy = options.ody;
	        } else {
	          throw is.invalidParameterError('options.ody', 'number', options.ody);
	        }
	      }
	      if (is.defined(options.interpolator)) {
	        if (is.inArray(options.interpolator, Object.values(this.constructor.interpolators))) {
	          this.options.affineInterpolator = options.interpolator;
	        } else {
	          throw is.invalidParameterError('options.interpolator', 'valid interpolator name', options.interpolator);
	        }
	      }
	    } else {
	      throw is.invalidParameterError('options', 'object', options);
	    }
	  }

	  return this;
	}

	/**
	 * Sharpen the image.
	 *
	 * When used without parameters, performs a fast, mild sharpen of the output image.
	 *
	 * When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space.
	 * Fine-grained control over the level of sharpening in "flat" (m1) and "jagged" (m2) areas is available.
	 *
	 * See {@link https://www.libvips.org/API/current/method.Image.sharpen.html libvips sharpen} operation.
	 *
	 * @example
	 * const data = await sharp(input).sharpen().toBuffer();
	 *
	 * @example
	 * const data = await sharp(input).sharpen({ sigma: 2 }).toBuffer();
	 *
	 * @example
	 * const data = await sharp(input)
	 *   .sharpen({
	 *     sigma: 2,
	 *     m1: 0,
	 *     m2: 3,
	 *     x1: 3,
	 *     y2: 15,
	 *     y3: 15,
	 *   })
	 *   .toBuffer();
	 *
	 * @param {Object|number} [options] - if present, is an Object with attributes
	 * @param {number} [options.sigma] - the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`, between 0.000001 and 10
	 * @param {number} [options.m1=1.0] - the level of sharpening to apply to "flat" areas, between 0 and 1000000
	 * @param {number} [options.m2=2.0] - the level of sharpening to apply to "jagged" areas, between 0 and 1000000
	 * @param {number} [options.x1=2.0] - threshold between "flat" and "jagged", between 0 and 1000000
	 * @param {number} [options.y2=10.0] - maximum amount of brightening, between 0 and 1000000
	 * @param {number} [options.y3=20.0] - maximum amount of darkening, between 0 and 1000000
	 * @param {number} [flat] - (deprecated) see `options.m1`.
	 * @param {number} [jagged] - (deprecated) see `options.m2`.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function sharpen (options, flat, jagged) {
	  if (!is.defined(options)) {
	    // No arguments: default to mild sharpen
	    this.options.sharpenSigma = -1;
	  } else if (is.bool(options)) {
	    // Deprecated boolean argument: apply mild sharpen?
	    this.options.sharpenSigma = options ? -1 : 0;
	  } else if (is.number(options) && is.inRange(options, 0.01, 10000)) {
	    // Deprecated numeric argument: specific sigma
	    this.options.sharpenSigma = options;
	    // Deprecated control over flat areas
	    if (is.defined(flat)) {
	      if (is.number(flat) && is.inRange(flat, 0, 10000)) {
	        this.options.sharpenM1 = flat;
	      } else {
	        throw is.invalidParameterError('flat', 'number between 0 and 10000', flat);
	      }
	    }
	    // Deprecated control over jagged areas
	    if (is.defined(jagged)) {
	      if (is.number(jagged) && is.inRange(jagged, 0, 10000)) {
	        this.options.sharpenM2 = jagged;
	      } else {
	        throw is.invalidParameterError('jagged', 'number between 0 and 10000', jagged);
	      }
	    }
	  } else if (is.plainObject(options)) {
	    if (is.number(options.sigma) && is.inRange(options.sigma, 0.000001, 10)) {
	      this.options.sharpenSigma = options.sigma;
	    } else {
	      throw is.invalidParameterError('options.sigma', 'number between 0.000001 and 10', options.sigma);
	    }
	    if (is.defined(options.m1)) {
	      if (is.number(options.m1) && is.inRange(options.m1, 0, 1000000)) {
	        this.options.sharpenM1 = options.m1;
	      } else {
	        throw is.invalidParameterError('options.m1', 'number between 0 and 1000000', options.m1);
	      }
	    }
	    if (is.defined(options.m2)) {
	      if (is.number(options.m2) && is.inRange(options.m2, 0, 1000000)) {
	        this.options.sharpenM2 = options.m2;
	      } else {
	        throw is.invalidParameterError('options.m2', 'number between 0 and 1000000', options.m2);
	      }
	    }
	    if (is.defined(options.x1)) {
	      if (is.number(options.x1) && is.inRange(options.x1, 0, 1000000)) {
	        this.options.sharpenX1 = options.x1;
	      } else {
	        throw is.invalidParameterError('options.x1', 'number between 0 and 1000000', options.x1);
	      }
	    }
	    if (is.defined(options.y2)) {
	      if (is.number(options.y2) && is.inRange(options.y2, 0, 1000000)) {
	        this.options.sharpenY2 = options.y2;
	      } else {
	        throw is.invalidParameterError('options.y2', 'number between 0 and 1000000', options.y2);
	      }
	    }
	    if (is.defined(options.y3)) {
	      if (is.number(options.y3) && is.inRange(options.y3, 0, 1000000)) {
	        this.options.sharpenY3 = options.y3;
	      } else {
	        throw is.invalidParameterError('options.y3', 'number between 0 and 1000000', options.y3);
	      }
	    }
	  } else {
	    throw is.invalidParameterError('sigma', 'number between 0.01 and 10000', options);
	  }
	  return this;
	}

	/**
	 * Apply median filter.
	 * When used without parameters the default window is 3x3.
	 *
	 * @example
	 * const output = await sharp(input).median().toBuffer();
	 *
	 * @example
	 * const output = await sharp(input).median(5).toBuffer();
	 *
	 * @param {number} [size=3] square mask size: size x size
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function median (size) {
	  if (!is.defined(size)) {
	    // No arguments: default to 3x3
	    this.options.medianSize = 3;
	  } else if (is.integer(size) && is.inRange(size, 1, 1000)) {
	    // Numeric argument: specific sigma
	    this.options.medianSize = size;
	  } else {
	    throw is.invalidParameterError('size', 'integer between 1 and 1000', size);
	  }
	  return this;
	}

	/**
	 * Blur the image.
	 *
	 * When used without parameters, performs a fast 3x3 box blur (equivalent to a box linear filter).
	 *
	 * When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
	 *
	 * @example
	 * const boxBlurred = await sharp(input)
	 *   .blur()
	 *   .toBuffer();
	 *
	 * @example
	 * const gaussianBlurred = await sharp(input)
	 *   .blur(5)
	 *   .toBuffer();
	 *
	 * @param {Object|number|Boolean} [options]
	 * @param {number} [options.sigma] a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
	 * @param {string} [options.precision='integer'] How accurate the operation should be, one of: integer, float, approximate.
	 * @param {number} [options.minAmplitude=0.2] A value between 0.001 and 1. A smaller value will generate a larger, more accurate mask.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function blur (options) {
	  let sigma;
	  if (is.number(options)) {
	    sigma = options;
	  } else if (is.plainObject(options)) {
	    if (!is.number(options.sigma)) {
	      throw is.invalidParameterError('options.sigma', 'number between 0.3 and 1000', sigma);
	    }
	    sigma = options.sigma;
	    if ('precision' in options) {
	      if (is.string(vipsPrecision[options.precision])) {
	        this.options.precision = vipsPrecision[options.precision];
	      } else {
	        throw is.invalidParameterError('precision', 'one of: integer, float, approximate', options.precision);
	      }
	    }
	    if ('minAmplitude' in options) {
	      if (is.number(options.minAmplitude) && is.inRange(options.minAmplitude, 0.001, 1)) {
	        this.options.minAmpl = options.minAmplitude;
	      } else {
	        throw is.invalidParameterError('minAmplitude', 'number between 0.001 and 1', options.minAmplitude);
	      }
	    }
	  }

	  if (!is.defined(options)) {
	    // No arguments: default to mild blur
	    this.options.blurSigma = -1;
	  } else if (is.bool(options)) {
	    // Boolean argument: apply mild blur?
	    this.options.blurSigma = options ? -1 : 0;
	  } else if (is.number(sigma) && is.inRange(sigma, 0.3, 1000)) {
	    // Numeric argument: specific sigma
	    this.options.blurSigma = sigma;
	  } else {
	    throw is.invalidParameterError('sigma', 'number between 0.3 and 1000', sigma);
	  }

	  return this;
	}

	/**
	 * Expand foreground objects using the dilate morphological operator.
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .dilate()
	 *   .toBuffer();
	 *
	 * @param {Number} [width=1] dilation width in pixels.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function dilate (width) {
	  if (!is.defined(width)) {
	    this.options.dilateWidth = 1;
	  } else if (is.integer(width) && width > 0) {
	    this.options.dilateWidth = width;
	  } else {
	    throw is.invalidParameterError('dilate', 'positive integer', dilate);
	  }
	  return this;
	}

	/**
	 * Shrink foreground objects using the erode morphological operator.
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .erode()
	 *   .toBuffer();
	 *
	 * @param {Number} [width=1] erosion width in pixels.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function erode (width) {
	  if (!is.defined(width)) {
	    this.options.erodeWidth = 1;
	  } else if (is.integer(width) && width > 0) {
	    this.options.erodeWidth = width;
	  } else {
	    throw is.invalidParameterError('erode', 'positive integer', erode);
	  }
	  return this;
	}

	/**
	 * Merge alpha transparency channel, if any, with a background, then remove the alpha channel.
	 *
	 * See also {@link /api-channel#removealpha removeAlpha}.
	 *
	 * @example
	 * await sharp(rgbaInput)
	 *   .flatten({ background: '#F0A703' })
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {string|Object} [options.background={r: 0, g: 0, b: 0}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to black.
	 * @returns {Sharp}
	 */
	function flatten (options) {
	  this.options.flatten = is.bool(options) ? options : true;
	  if (is.object(options)) {
	    this._setBackgroundColourOption('flattenBackground', options.background);
	  }
	  return this;
	}

	/**
	 * Ensure the image has an alpha channel
	 * with all white pixel values made fully transparent.
	 *
	 * Existing alpha channel values for non-white pixels remain unchanged.
	 *
	 * This feature is experimental and the API may change.
	 *
	 * @since 0.32.1
	 *
	 * @example
	 * await sharp(rgbInput)
	 *   .unflatten()
	 *   .toBuffer();
	 *
	 * @example
	 * await sharp(rgbInput)
	 *   .threshold(128, { grayscale: false }) // converter bright pixels to white
	 *   .unflatten()
	 *   .toBuffer();
	 */
	function unflatten () {
	  this.options.unflatten = true;
	  return this;
	}

	/**
	 * Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma`
	 * then increasing the encoding (brighten) post-resize at a factor of `gamma`.
	 * This can improve the perceived brightness of a resized image in non-linear colour spaces.
	 * JPEG and WebP input images will not take advantage of the shrink-on-load performance optimisation
	 * when applying a gamma correction.
	 *
	 * Supply a second argument to use a different output gamma value, otherwise the first value is used in both cases.
	 *
	 * @param {number} [gamma=2.2] value between 1.0 and 3.0.
	 * @param {number} [gammaOut] value between 1.0 and 3.0. (optional, defaults to same as `gamma`)
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function gamma (gamma, gammaOut) {
	  if (!is.defined(gamma)) {
	    // Default gamma correction of 2.2 (sRGB)
	    this.options.gamma = 2.2;
	  } else if (is.number(gamma) && is.inRange(gamma, 1, 3)) {
	    this.options.gamma = gamma;
	  } else {
	    throw is.invalidParameterError('gamma', 'number between 1.0 and 3.0', gamma);
	  }
	  if (!is.defined(gammaOut)) {
	    // Default gamma correction for output is same as input
	    this.options.gammaOut = this.options.gamma;
	  } else if (is.number(gammaOut) && is.inRange(gammaOut, 1, 3)) {
	    this.options.gammaOut = gammaOut;
	  } else {
	    throw is.invalidParameterError('gammaOut', 'number between 1.0 and 3.0', gammaOut);
	  }
	  return this;
	}

	/**
	 * Produce the "negative" of the image.
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .negate()
	 *   .toBuffer();
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .negate({ alpha: false })
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {Boolean} [options.alpha=true] Whether or not to negate any alpha channel
	 * @returns {Sharp}
	 */
	function negate (options) {
	  this.options.negate = is.bool(options) ? options : true;
	  if (is.plainObject(options) && 'alpha' in options) {
	    if (!is.bool(options.alpha)) {
	      throw is.invalidParameterError('alpha', 'should be boolean value', options.alpha);
	    } else {
	      this.options.negateAlpha = options.alpha;
	    }
	  }
	  return this;
	}

	/**
	 * Enhance output image contrast by stretching its luminance to cover a full dynamic range.
	 *
	 * Uses a histogram-based approach, taking a default range of 1% to 99% to reduce sensitivity to noise at the extremes.
	 *
	 * Luminance values below the `lower` percentile will be underexposed by clipping to zero.
	 * Luminance values above the `upper` percentile will be overexposed by clipping to the max pixel value.
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .normalise()
	 *   .toBuffer();
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .normalise({ lower: 0, upper: 100 })
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {number} [options.lower=1] - Percentile below which luminance values will be underexposed.
	 * @param {number} [options.upper=99] - Percentile above which luminance values will be overexposed.
	 * @returns {Sharp}
	 */
	function normalise (options) {
	  if (is.plainObject(options)) {
	    if (is.defined(options.lower)) {
	      if (is.number(options.lower) && is.inRange(options.lower, 0, 99)) {
	        this.options.normaliseLower = options.lower;
	      } else {
	        throw is.invalidParameterError('lower', 'number between 0 and 99', options.lower);
	      }
	    }
	    if (is.defined(options.upper)) {
	      if (is.number(options.upper) && is.inRange(options.upper, 1, 100)) {
	        this.options.normaliseUpper = options.upper;
	      } else {
	        throw is.invalidParameterError('upper', 'number between 1 and 100', options.upper);
	      }
	    }
	  }
	  if (this.options.normaliseLower >= this.options.normaliseUpper) {
	    throw is.invalidParameterError('range', 'lower to be less than upper',
	      `${this.options.normaliseLower} >= ${this.options.normaliseUpper}`);
	  }
	  this.options.normalise = true;
	  return this;
	}

	/**
	 * Alternative spelling of normalise.
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .normalize()
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {number} [options.lower=1] - Percentile below which luminance values will be underexposed.
	 * @param {number} [options.upper=99] - Percentile above which luminance values will be overexposed.
	 * @returns {Sharp}
	 */
	function normalize (options) {
	  return this.normalise(options);
	}

	/**
	 * Perform contrast limiting adaptive histogram equalization
	 * {@link https://en.wikipedia.org/wiki/Adaptive_histogram_equalization#Contrast_Limited_AHE CLAHE}.
	 *
	 * This will, in general, enhance the clarity of the image by bringing out darker details.
	 *
	 * @since 0.28.3
	 *
	 * @example
	 * const output = await sharp(input)
	 *   .clahe({
	 *     width: 3,
	 *     height: 3,
	 *   })
	 *   .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.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) {
	      this.options.claheWidth = options.width;
	    } else {
	      throw is.invalidParameterError('width', 'integer greater than zero', options.width);
	    }
	    if (is.integer(options.height) && options.height > 0) {
	      this.options.claheHeight = options.height;
	    } else {
	      throw is.invalidParameterError('height', 'integer greater than zero', options.height);
	    }
	    if (is.defined(options.maxSlope)) {
	      if (is.integer(options.maxSlope) && is.inRange(options.maxSlope, 0, 100)) {
	        this.options.claheMaxSlope = options.maxSlope;
	      } else {
	        throw is.invalidParameterError('maxSlope', 'integer between 0 and 100', options.maxSlope);
	      }
	    }
	  } else {
	    throw is.invalidParameterError('options', 'plain object', options);
	  }
	  return this;
	}

	/**
	 * Convolve the image with the specified kernel.
	 *
	 * @example
	 * sharp(input)
	 *   .convolve({
	 *     width: 3,
	 *     height: 3,
	 *     kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
	 *   })
	 *   .raw()
	 *   .toBuffer(function(err, data, info) {
	 *     // data contains the raw pixel data representing the convolution
	 *     // of the input image with the horizontal Sobel operator
	 *   });
	 *
	 * @param {Object} kernel
	 * @param {number} kernel.width - width of the kernel in pixels.
	 * @param {number} kernel.height - height of the kernel in pixels.
	 * @param {Array<number>} kernel.kernel - Array of length `width*height` containing the kernel values.
	 * @param {number} [kernel.scale=sum] - the scale of the kernel in pixels.
	 * @param {number} [kernel.offset=0] - the offset of the kernel in pixels.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function convolve (kernel) {
	  if (!is.object(kernel) || !Array.isArray(kernel.kernel) ||
	      !is.integer(kernel.width) || !is.integer(kernel.height) ||
	      !is.inRange(kernel.width, 3, 1001) || !is.inRange(kernel.height, 3, 1001) ||
	      kernel.height * kernel.width !== kernel.kernel.length
	  ) {
	    // must pass in a kernel
	    throw new Error('Invalid convolution kernel');
	  }
	  // Default scale is sum of kernel values
	  if (!is.integer(kernel.scale)) {
	    kernel.scale = kernel.kernel.reduce((a, b) => a + b, 0);
	  }
	  // Clip scale to a minimum value of 1
	  if (kernel.scale < 1) {
	    kernel.scale = 1;
	  }
	  if (!is.integer(kernel.offset)) {
	    kernel.offset = 0;
	  }
	  this.options.convKernel = kernel;
	  return this;
	}

	/**
	 * Any pixel value greater than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
	 * @param {number} [threshold=128] - a value in the range 0-255 representing the level at which the threshold will be applied.
	 * @param {Object} [options]
	 * @param {Boolean} [options.greyscale=true] - convert to single channel greyscale.
	 * @param {Boolean} [options.grayscale=true] - alternative spelling for greyscale.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function threshold (threshold, options) {
	  if (!is.defined(threshold)) {
	    this.options.threshold = 128;
	  } else if (is.bool(threshold)) {
	    this.options.threshold = threshold ? 128 : 0;
	  } else if (is.integer(threshold) && is.inRange(threshold, 0, 255)) {
	    this.options.threshold = threshold;
	  } else {
	    throw is.invalidParameterError('threshold', 'integer between 0 and 255', threshold);
	  }
	  if (!is.object(options) || options.greyscale === true || options.grayscale === true) {
	    this.options.thresholdGrayscale = true;
	  } else {
	    this.options.thresholdGrayscale = false;
	  }
	  return this;
	}

	/**
	 * Perform a bitwise boolean operation with operand image.
	 *
	 * This operation creates an output image where each pixel is the result of
	 * the selected bitwise boolean `operation` between the corresponding pixels of the input images.
	 *
	 * @param {Buffer|string} operand - Buffer containing image data or string containing the path to an image file.
	 * @param {string} operator - one of `and`, `or` or `eor` to perform that bitwise operation, like the C logic operators `&`, `|` and `^` respectively.
	 * @param {Object} [options]
	 * @param {Object} [options.raw] - describes operand when using raw pixel data.
	 * @param {number} [options.raw.width]
	 * @param {number} [options.raw.height]
	 * @param {number} [options.raw.channels]
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function boolean (operand, operator, options) {
	  this.options.boolean = this._createInputDescriptor(operand, options);
	  if (is.string(operator) && is.inArray(operator, ['and', 'or', 'eor'])) {
	    this.options.booleanOp = operator;
	  } else {
	    throw is.invalidParameterError('operator', 'one of: and, or, eor', operator);
	  }
	  return this;
	}

	/**
	 * Apply the linear formula `a` * input + `b` to the image to adjust image levels.
	 *
	 * When a single number is provided, it will be used for all image channels.
	 * When an array of numbers is provided, the array length must match the number of channels.
	 *
	 * @example
	 * await sharp(input)
	 *   .linear(0.5, 2)
	 *   .toBuffer();
	 *
	 * @example
	 * await sharp(rgbInput)
	 *   .linear(
	 *     [0.25, 0.5, 0.75],
	 *     [150, 100, 50]
	 *   )
	 *   .toBuffer();
	 *
	 * @param {(number|number[])} [a=[]] multiplier
	 * @param {(number|number[])} [b=[]] offset
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function linear (a, b) {
	  if (!is.defined(a) && is.number(b)) {
	    a = 1.0;
	  } else if (is.number(a) && !is.defined(b)) {
	    b = 0.0;
	  }
	  if (!is.defined(a)) {
	    this.options.linearA = [];
	  } else if (is.number(a)) {
	    this.options.linearA = [a];
	  } else if (Array.isArray(a) && a.length && a.every(is.number)) {
	    this.options.linearA = a;
	  } else {
	    throw is.invalidParameterError('a', 'number or array of numbers', a);
	  }
	  if (!is.defined(b)) {
	    this.options.linearB = [];
	  } else if (is.number(b)) {
	    this.options.linearB = [b];
	  } else if (Array.isArray(b) && b.length && b.every(is.number)) {
	    this.options.linearB = b;
	  } else {
	    throw is.invalidParameterError('b', 'number or array of numbers', b);
	  }
	  if (this.options.linearA.length !== this.options.linearB.length) {
	    throw new Error('Expected a and b to be arrays of the same length');
	  }
	  return this;
	}

	/**
	 * Recombine the image with the specified matrix.
	 *
	 * @since 0.21.1
	 *
	 * @example
	 * sharp(input)
	 *   .recomb([
	 *    [0.3588, 0.7044, 0.1368],
	 *    [0.2990, 0.5870, 0.1140],
	 *    [0.2392, 0.4696, 0.0912],
	 *   ])
	 *   .raw()
	 *   .toBuffer(function(err, data, info) {
	 *     // data contains the raw pixel data after applying the matrix
	 *     // With this example input, a sepia filter has been applied
	 *   });
	 *
	 * @param {Array<Array<number>>} inputMatrix - 3x3 or 4x4 Recombination matrix
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	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 recombMatrix = inputMatrix.flat().map(Number);
	  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
	    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
	  }
	  this.options.recombMatrix = recombMatrix;
	  return this;
	}

	/**
	 * Transforms the image using brightness, saturation, hue rotation, and lightness.
	 * Brightness and lightness both operate on luminance, with the difference being that
	 * brightness is multiplicative whereas lightness is additive.
	 *
	 * @since 0.22.1
	 *
	 * @example
	 * // increase brightness by a factor of 2
	 * const output = await sharp(input)
	 *   .modulate({
	 *     brightness: 2
	 *   })
	 *   .toBuffer();
	 *
	 * @example
	 * // hue-rotate by 180 degrees
	 * const output = await sharp(input)
	 *   .modulate({
	 *     hue: 180
	 *   })
	 *   .toBuffer();
	 *
	 * @example
	 * // increase lightness by +50
	 * const output = await sharp(input)
	 *   .modulate({
	 *     lightness: 50
	 *   })
	 *   .toBuffer();
	 *
	 * @example
	 * // decrease brightness and saturation while also hue-rotating by 90 degrees
	 * const output = await sharp(input)
	 *   .modulate({
	 *     brightness: 0.5,
	 *     saturation: 0.5,
	 *     hue: 90,
	 *   })
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {number} [options.brightness] Brightness multiplier
	 * @param {number} [options.saturation] Saturation multiplier
	 * @param {number} [options.hue] Degrees for hue rotation
	 * @param {number} [options.lightness] Lightness addend
	 * @returns {Sharp}
	 */
	function modulate (options) {
	  if (!is.plainObject(options)) {
	    throw is.invalidParameterError('options', 'plain object', options);
	  }
	  if ('brightness' in options) {
	    if (is.number(options.brightness) && options.brightness >= 0) {
	      this.options.brightness = options.brightness;
	    } else {
	      throw is.invalidParameterError('brightness', 'number above zero', options.brightness);
	    }
	  }
	  if ('saturation' in options) {
	    if (is.number(options.saturation) && options.saturation >= 0) {
	      this.options.saturation = options.saturation;
	    } else {
	      throw is.invalidParameterError('saturation', 'number above zero', options.saturation);
	    }
	  }
	  if ('hue' in options) {
	    if (is.integer(options.hue)) {
	      this.options.hue = options.hue % 360;
	    } else {
	      throw is.invalidParameterError('hue', 'number', options.hue);
	    }
	  }
	  if ('lightness' in options) {
	    if (is.number(options.lightness)) {
	      this.options.lightness = options.lightness;
	    } else {
	      throw is.invalidParameterError('lightness', 'number', options.lightness);
	    }
	  }
	  return this;
	}

	/**
	 * Decorate the Sharp prototype with operation-related functions.
	 * @module Sharp
	 * @private
	 */
	operation = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    autoOrient,
	    rotate,
	    flip,
	    flop,
	    affine,
	    sharpen,
	    erode,
	    dilate,
	    median,
	    blur,
	    flatten,
	    unflatten,
	    gamma,
	    negate,
	    normalise,
	    normalize,
	    clahe,
	    convolve,
	    threshold,
	    boolean,
	    linear,
	    recomb,
	    modulate
	  });
	};
	return operation;
}

var color;
var hasRequiredColor;

function requireColor () {
	if (hasRequiredColor) return color;
	hasRequiredColor = 1;
	var __defProp = Object.defineProperty;
	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
	var __getOwnPropNames = Object.getOwnPropertyNames;
	var __hasOwnProp = Object.prototype.hasOwnProperty;
	var __export = (target, all) => {
	  for (var name in all)
	    __defProp(target, name, { get: all[name], enumerable: true });
	};
	var __copyProps = (to, from, except, desc) => {
	  if (from && typeof from === "object" || typeof from === "function") {
	    for (let key of __getOwnPropNames(from))
	      if (!__hasOwnProp.call(to, key) && key !== except)
	        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
	  }
	  return to;
	};
	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

	// node_modules/color/index.js
	var index_exports = {};
	__export(index_exports, {
	  default: () => index_default
	});
	color = __toCommonJS(index_exports);

	// node_modules/color-name/index.js
	var colors = {
	  aliceblue: [240, 248, 255],
	  antiquewhite: [250, 235, 215],
	  aqua: [0, 255, 255],
	  aquamarine: [127, 255, 212],
	  azure: [240, 255, 255],
	  beige: [245, 245, 220],
	  bisque: [255, 228, 196],
	  black: [0, 0, 0],
	  blanchedalmond: [255, 235, 205],
	  blue: [0, 0, 255],
	  blueviolet: [138, 43, 226],
	  brown: [165, 42, 42],
	  burlywood: [222, 184, 135],
	  cadetblue: [95, 158, 160],
	  chartreuse: [127, 255, 0],
	  chocolate: [210, 105, 30],
	  coral: [255, 127, 80],
	  cornflowerblue: [100, 149, 237],
	  cornsilk: [255, 248, 220],
	  crimson: [220, 20, 60],
	  cyan: [0, 255, 255],
	  darkblue: [0, 0, 139],
	  darkcyan: [0, 139, 139],
	  darkgoldenrod: [184, 134, 11],
	  darkgray: [169, 169, 169],
	  darkgreen: [0, 100, 0],
	  darkgrey: [169, 169, 169],
	  darkkhaki: [189, 183, 107],
	  darkmagenta: [139, 0, 139],
	  darkolivegreen: [85, 107, 47],
	  darkorange: [255, 140, 0],
	  darkorchid: [153, 50, 204],
	  darkred: [139, 0, 0],
	  darksalmon: [233, 150, 122],
	  darkseagreen: [143, 188, 143],
	  darkslateblue: [72, 61, 139],
	  darkslategray: [47, 79, 79],
	  darkslategrey: [47, 79, 79],
	  darkturquoise: [0, 206, 209],
	  darkviolet: [148, 0, 211],
	  deeppink: [255, 20, 147],
	  deepskyblue: [0, 191, 255],
	  dimgray: [105, 105, 105],
	  dimgrey: [105, 105, 105],
	  dodgerblue: [30, 144, 255],
	  firebrick: [178, 34, 34],
	  floralwhite: [255, 250, 240],
	  forestgreen: [34, 139, 34],
	  fuchsia: [255, 0, 255],
	  gainsboro: [220, 220, 220],
	  ghostwhite: [248, 248, 255],
	  gold: [255, 215, 0],
	  goldenrod: [218, 165, 32],
	  gray: [128, 128, 128],
	  green: [0, 128, 0],
	  greenyellow: [173, 255, 47],
	  grey: [128, 128, 128],
	  honeydew: [240, 255, 240],
	  hotpink: [255, 105, 180],
	  indianred: [205, 92, 92],
	  indigo: [75, 0, 130],
	  ivory: [255, 255, 240],
	  khaki: [240, 230, 140],
	  lavender: [230, 230, 250],
	  lavenderblush: [255, 240, 245],
	  lawngreen: [124, 252, 0],
	  lemonchiffon: [255, 250, 205],
	  lightblue: [173, 216, 230],
	  lightcoral: [240, 128, 128],
	  lightcyan: [224, 255, 255],
	  lightgoldenrodyellow: [250, 250, 210],
	  lightgray: [211, 211, 211],
	  lightgreen: [144, 238, 144],
	  lightgrey: [211, 211, 211],
	  lightpink: [255, 182, 193],
	  lightsalmon: [255, 160, 122],
	  lightseagreen: [32, 178, 170],
	  lightskyblue: [135, 206, 250],
	  lightslategray: [119, 136, 153],
	  lightslategrey: [119, 136, 153],
	  lightsteelblue: [176, 196, 222],
	  lightyellow: [255, 255, 224],
	  lime: [0, 255, 0],
	  limegreen: [50, 205, 50],
	  linen: [250, 240, 230],
	  magenta: [255, 0, 255],
	  maroon: [128, 0, 0],
	  mediumaquamarine: [102, 205, 170],
	  mediumblue: [0, 0, 205],
	  mediumorchid: [186, 85, 211],
	  mediumpurple: [147, 112, 219],
	  mediumseagreen: [60, 179, 113],
	  mediumslateblue: [123, 104, 238],
	  mediumspringgreen: [0, 250, 154],
	  mediumturquoise: [72, 209, 204],
	  mediumvioletred: [199, 21, 133],
	  midnightblue: [25, 25, 112],
	  mintcream: [245, 255, 250],
	  mistyrose: [255, 228, 225],
	  moccasin: [255, 228, 181],
	  navajowhite: [255, 222, 173],
	  navy: [0, 0, 128],
	  oldlace: [253, 245, 230],
	  olive: [128, 128, 0],
	  olivedrab: [107, 142, 35],
	  orange: [255, 165, 0],
	  orangered: [255, 69, 0],
	  orchid: [218, 112, 214],
	  palegoldenrod: [238, 232, 170],
	  palegreen: [152, 251, 152],
	  paleturquoise: [175, 238, 238],
	  palevioletred: [219, 112, 147],
	  papayawhip: [255, 239, 213],
	  peachpuff: [255, 218, 185],
	  peru: [205, 133, 63],
	  pink: [255, 192, 203],
	  plum: [221, 160, 221],
	  powderblue: [176, 224, 230],
	  purple: [128, 0, 128],
	  rebeccapurple: [102, 51, 153],
	  red: [255, 0, 0],
	  rosybrown: [188, 143, 143],
	  royalblue: [65, 105, 225],
	  saddlebrown: [139, 69, 19],
	  salmon: [250, 128, 114],
	  sandybrown: [244, 164, 96],
	  seagreen: [46, 139, 87],
	  seashell: [255, 245, 238],
	  sienna: [160, 82, 45],
	  silver: [192, 192, 192],
	  skyblue: [135, 206, 235],
	  slateblue: [106, 90, 205],
	  slategray: [112, 128, 144],
	  slategrey: [112, 128, 144],
	  snow: [255, 250, 250],
	  springgreen: [0, 255, 127],
	  steelblue: [70, 130, 180],
	  tan: [210, 180, 140],
	  teal: [0, 128, 128],
	  thistle: [216, 191, 216],
	  tomato: [255, 99, 71],
	  turquoise: [64, 224, 208],
	  violet: [238, 130, 238],
	  wheat: [245, 222, 179],
	  white: [255, 255, 255],
	  whitesmoke: [245, 245, 245],
	  yellow: [255, 255, 0],
	  yellowgreen: [154, 205, 50]
	};
	for (const key in colors) Object.freeze(colors[key]);
	var color_name_default = Object.freeze(colors);

	// node_modules/color-string/index.js
	var reverseNames = /* @__PURE__ */ Object.create(null);
	for (const name in color_name_default) {
	  if (Object.hasOwn(color_name_default, name)) {
	    reverseNames[color_name_default[name]] = name;
	  }
	}
	var cs = {
	  to: {},
	  get: {}
	};
	cs.get = function(string) {
	  const prefix = string.slice(0, 3).toLowerCase();
	  let value;
	  let model;
	  switch (prefix) {
	    case "hsl": {
	      value = cs.get.hsl(string);
	      model = "hsl";
	      break;
	    }
	    case "hwb": {
	      value = cs.get.hwb(string);
	      model = "hwb";
	      break;
	    }
	    default: {
	      value = cs.get.rgb(string);
	      model = "rgb";
	      break;
	    }
	  }
	  if (!value) {
	    return null;
	  }
	  return { model, value };
	};
	cs.get.rgb = function(string) {
	  if (!string) {
	    return null;
	  }
	  const abbr = /^#([a-f\d]{3,4})$/i;
	  const hex = /^#([a-f\d]{6})([a-f\d]{2})?$/i;
	  const rgba = /^rgba?\(\s*([+-]?(?:\d*\.)?\d+(?:e\d+)?)(?=[\s,])\s*(?:,\s*)?([+-]?(?:\d*\.)?\d+(?:e\d+)?)(?=[\s,])\s*(?:,\s*)?([+-]?(?:\d*\.)?\d+(?:e\d+)?)\s*(?:[\s,|/]\s*([+-]?(?:\d*\.)?\d+(?:e\d+)?)(%?)\s*)?\)$/i;
	  const per = /^rgba?\(\s*([+-]?[\d.]+)%\s*,?\s*([+-]?[\d.]+)%\s*,?\s*([+-]?[\d.]+)%\s*(?:[\s,|/]\s*([+-]?[\d.]+)(%?)\s*)?\)$/i;
	  const keyword = /^(\w+)$/;
	  let rgb = [0, 0, 0, 1];
	  let match;
	  let i;
	  let hexAlpha;
	  if (match = string.match(hex)) {
	    hexAlpha = match[2];
	    match = match[1];
	    for (i = 0; i < 3; i++) {
	      const i2 = i * 2;
	      rgb[i] = Number.parseInt(match.slice(i2, i2 + 2), 16);
	    }
	    if (hexAlpha) {
	      rgb[3] = Number.parseInt(hexAlpha, 16) / 255;
	    }
	  } else if (match = string.match(abbr)) {
	    match = match[1];
	    hexAlpha = match[3];
	    for (i = 0; i < 3; i++) {
	      rgb[i] = Number.parseInt(match[i] + match[i], 16);
	    }
	    if (hexAlpha) {
	      rgb[3] = Number.parseInt(hexAlpha + hexAlpha, 16) / 255;
	    }
	  } else if (match = string.match(rgba)) {
	    for (i = 0; i < 3; i++) {
	      rgb[i] = Number.parseFloat(match[i + 1]);
	    }
	    if (match[4]) {
	      rgb[3] = match[5] ? Number.parseFloat(match[4]) * 0.01 : Number.parseFloat(match[4]);
	    }
	  } else if (match = string.match(per)) {
	    for (i = 0; i < 3; i++) {
	      rgb[i] = Math.round(Number.parseFloat(match[i + 1]) * 2.55);
	    }
	    if (match[4]) {
	      rgb[3] = match[5] ? Number.parseFloat(match[4]) * 0.01 : Number.parseFloat(match[4]);
	    }
	  } else if (match = string.toLowerCase().match(keyword)) {
	    if (match[1] === "transparent") {
	      return [0, 0, 0, 0];
	    }
	    if (!Object.hasOwn(color_name_default, match[1])) {
	      return null;
	    }
	    rgb = color_name_default[match[1]].slice();
	    rgb[3] = 1;
	    return rgb;
	  } else {
	    return null;
	  }
	  for (i = 0; i < 3; i++) {
	    rgb[i] = clamp(rgb[i], 0, 255);
	  }
	  rgb[3] = clamp(rgb[3], 0, 1);
	  return rgb;
	};
	cs.get.hsl = function(string) {
	  if (!string) {
	    return null;
	  }
	  const hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d.]+)%\s*,?\s*([+-]?[\d.]+)%\s*(?:[,|/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:e[+-]?\d+)?)\s*)?\)$/i;
	  const match = string.match(hsl);
	  if (match) {
	    const alpha = Number.parseFloat(match[4]);
	    const h = (Number.parseFloat(match[1]) % 360 + 360) % 360;
	    const s = clamp(Number.parseFloat(match[2]), 0, 100);
	    const l = clamp(Number.parseFloat(match[3]), 0, 100);
	    const a = clamp(Number.isNaN(alpha) ? 1 : alpha, 0, 1);
	    return [h, s, l, a];
	  }
	  return null;
	};
	cs.get.hwb = function(string) {
	  if (!string) {
	    return null;
	  }
	  const hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*[\s,]\s*([+-]?[\d.]+)%\s*[\s,]\s*([+-]?[\d.]+)%\s*(?:[\s,]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:e[+-]?\d+)?)\s*)?\)$/i;
	  const match = string.match(hwb);
	  if (match) {
	    const alpha = Number.parseFloat(match[4]);
	    const h = (Number.parseFloat(match[1]) % 360 + 360) % 360;
	    const w = clamp(Number.parseFloat(match[2]), 0, 100);
	    const b = clamp(Number.parseFloat(match[3]), 0, 100);
	    const a = clamp(Number.isNaN(alpha) ? 1 : alpha, 0, 1);
	    return [h, w, b, a];
	  }
	  return null;
	};
	cs.to.hex = function(...rgba) {
	  return "#" + hexDouble(rgba[0]) + hexDouble(rgba[1]) + hexDouble(rgba[2]) + (rgba[3] < 1 ? hexDouble(Math.round(rgba[3] * 255)) : "");
	};
	cs.to.rgb = function(...rgba) {
	  return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ")" : "rgba(" + Math.round(rgba[0]) + ", " + Math.round(rgba[1]) + ", " + Math.round(rgba[2]) + ", " + rgba[3] + ")";
	};
	cs.to.rgb.percent = function(...rgba) {
	  const r = Math.round(rgba[0] / 255 * 100);
	  const g = Math.round(rgba[1] / 255 * 100);
	  const b = Math.round(rgba[2] / 255 * 100);
	  return rgba.length < 4 || rgba[3] === 1 ? "rgb(" + r + "%, " + g + "%, " + b + "%)" : "rgba(" + r + "%, " + g + "%, " + b + "%, " + rgba[3] + ")";
	};
	cs.to.hsl = function(...hsla) {
	  return hsla.length < 4 || hsla[3] === 1 ? "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)" : "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " + hsla[3] + ")";
	};
	cs.to.hwb = function(...hwba) {
	  let a = "";
	  if (hwba.length >= 4 && hwba[3] !== 1) {
	    a = ", " + hwba[3];
	  }
	  return "hwb(" + hwba[0] + ", " + hwba[1] + "%, " + hwba[2] + "%" + a + ")";
	};
	cs.to.keyword = function(...rgb) {
	  return reverseNames[rgb.slice(0, 3)];
	};
	function clamp(number_, min, max) {
	  return Math.min(Math.max(min, number_), max);
	}
	function hexDouble(number_) {
	  const string_ = Math.round(number_).toString(16).toUpperCase();
	  return string_.length < 2 ? "0" + string_ : string_;
	}
	var color_string_default = cs;

	// node_modules/color-convert/conversions.js
	var reverseKeywords = {};
	for (const key of Object.keys(color_name_default)) {
	  reverseKeywords[color_name_default[key]] = key;
	}
	var convert = {
	  rgb: { channels: 3, labels: "rgb" },
	  hsl: { channels: 3, labels: "hsl" },
	  hsv: { channels: 3, labels: "hsv" },
	  hwb: { channels: 3, labels: "hwb" },
	  cmyk: { channels: 4, labels: "cmyk" },
	  xyz: { channels: 3, labels: "xyz" },
	  lab: { channels: 3, labels: "lab" },
	  oklab: { channels: 3, labels: ["okl", "oka", "okb"] },
	  lch: { channels: 3, labels: "lch" },
	  oklch: { channels: 3, labels: ["okl", "okc", "okh"] },
	  hex: { channels: 1, labels: ["hex"] },
	  keyword: { channels: 1, labels: ["keyword"] },
	  ansi16: { channels: 1, labels: ["ansi16"] },
	  ansi256: { channels: 1, labels: ["ansi256"] },
	  hcg: { channels: 3, labels: ["h", "c", "g"] },
	  apple: { channels: 3, labels: ["r16", "g16", "b16"] },
	  gray: { channels: 1, labels: ["gray"] }
	};
	var conversions_default = convert;
	var LAB_FT = (6 / 29) ** 3;
	function srgbNonlinearTransform(c) {
	  const cc = c > 31308e-7 ? 1.055 * c ** (1 / 2.4) - 0.055 : c * 12.92;
	  return Math.min(Math.max(0, cc), 1);
	}
	function srgbNonlinearTransformInv(c) {
	  return c > 0.04045 ? ((c + 0.055) / 1.055) ** 2.4 : c / 12.92;
	}
	for (const model of Object.keys(convert)) {
	  if (!("channels" in convert[model])) {
	    throw new Error("missing channels property: " + model);
	  }
	  if (!("labels" in convert[model])) {
	    throw new Error("missing channel labels property: " + model);
	  }
	  if (convert[model].labels.length !== convert[model].channels) {
	    throw new Error("channel and label counts mismatch: " + model);
	  }
	  const { channels, labels } = convert[model];
	  delete convert[model].channels;
	  delete convert[model].labels;
	  Object.defineProperty(convert[model], "channels", { value: channels });
	  Object.defineProperty(convert[model], "labels", { value: labels });
	}
	convert.rgb.hsl = function(rgb) {
	  const r = rgb[0] / 255;
	  const g = rgb[1] / 255;
	  const b = rgb[2] / 255;
	  const min = Math.min(r, g, b);
	  const max = Math.max(r, g, b);
	  const delta = max - min;
	  let h;
	  let s;
	  switch (max) {
	    case min: {
	      h = 0;
	      break;
	    }
	    case r: {
	      h = (g - b) / delta;
	      break;
	    }
	    case g: {
	      h = 2 + (b - r) / delta;
	      break;
	    }
	    case b: {
	      h = 4 + (r - g) / delta;
	      break;
	    }
	  }
	  h = Math.min(h * 60, 360);
	  if (h < 0) {
	    h += 360;
	  }
	  const l = (min + max) / 2;
	  if (max === min) {
	    s = 0;
	  } else if (l <= 0.5) {
	    s = delta / (max + min);
	  } else {
	    s = delta / (2 - max - min);
	  }
	  return [h, s * 100, l * 100];
	};
	convert.rgb.hsv = function(rgb) {
	  let rdif;
	  let gdif;
	  let bdif;
	  let h;
	  let s;
	  const r = rgb[0] / 255;
	  const g = rgb[1] / 255;
	  const b = rgb[2] / 255;
	  const v = Math.max(r, g, b);
	  const diff = v - Math.min(r, g, b);
	  const diffc = function(c) {
	    return (v - c) / 6 / diff + 1 / 2;
	  };
	  if (diff === 0) {
	    h = 0;
	    s = 0;
	  } else {
	    s = diff / v;
	    rdif = diffc(r);
	    gdif = diffc(g);
	    bdif = diffc(b);
	    switch (v) {
	      case r: {
	        h = bdif - gdif;
	        break;
	      }
	      case g: {
	        h = 1 / 3 + rdif - bdif;
	        break;
	      }
	      case b: {
	        h = 2 / 3 + gdif - rdif;
	        break;
	      }
	    }
	    if (h < 0) {
	      h += 1;
	    } else if (h > 1) {
	      h -= 1;
	    }
	  }
	  return [
	    h * 360,
	    s * 100,
	    v * 100
	  ];
	};
	convert.rgb.hwb = function(rgb) {
	  const r = rgb[0];
	  const g = rgb[1];
	  let b = rgb[2];
	  const h = convert.rgb.hsl(rgb)[0];
	  const w = 1 / 255 * Math.min(r, Math.min(g, b));
	  b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
	  return [h, w * 100, b * 100];
	};
	convert.rgb.oklab = function(rgb) {
	  const r = srgbNonlinearTransformInv(rgb[0] / 255);
	  const g = srgbNonlinearTransformInv(rgb[1] / 255);
	  const b = srgbNonlinearTransformInv(rgb[2] / 255);
	  const lp = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
	  const mp = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
	  const sp = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
	  const l = 0.2104542553 * lp + 0.793617785 * mp - 0.0040720468 * sp;
	  const aa = 1.9779984951 * lp - 2.428592205 * mp + 0.4505937099 * sp;
	  const bb = 0.0259040371 * lp + 0.7827717662 * mp - 0.808675766 * sp;
	  return [l * 100, aa * 100, bb * 100];
	};
	convert.rgb.cmyk = function(rgb) {
	  const r = rgb[0] / 255;
	  const g = rgb[1] / 255;
	  const b = rgb[2] / 255;
	  const k = Math.min(1 - r, 1 - g, 1 - b);
	  const c = (1 - r - k) / (1 - k) || 0;
	  const m = (1 - g - k) / (1 - k) || 0;
	  const y = (1 - b - k) / (1 - k) || 0;
	  return [c * 100, m * 100, y * 100, k * 100];
	};
	function comparativeDistance(x, y) {
	  return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
	}
	convert.rgb.keyword = function(rgb) {
	  const reversed = reverseKeywords[rgb];
	  if (reversed) {
	    return reversed;
	  }
	  let currentClosestDistance = Number.POSITIVE_INFINITY;
	  let currentClosestKeyword;
	  for (const keyword of Object.keys(color_name_default)) {
	    const value = color_name_default[keyword];
	    const distance = comparativeDistance(rgb, value);
	    if (distance < currentClosestDistance) {
	      currentClosestDistance = distance;
	      currentClosestKeyword = keyword;
	    }
	  }
	  return currentClosestKeyword;
	};
	convert.keyword.rgb = function(keyword) {
	  return [...color_name_default[keyword]];
	};
	convert.rgb.xyz = function(rgb) {
	  const r = srgbNonlinearTransformInv(rgb[0] / 255);
	  const g = srgbNonlinearTransformInv(rgb[1] / 255);
	  const b = srgbNonlinearTransformInv(rgb[2] / 255);
	  const x = r * 0.4124564 + g * 0.3575761 + b * 0.1804375;
	  const y = r * 0.2126729 + g * 0.7151522 + b * 0.072175;
	  const z = r * 0.0193339 + g * 0.119192 + b * 0.9503041;
	  return [x * 100, y * 100, z * 100];
	};
	convert.rgb.lab = function(rgb) {
	  const xyz = convert.rgb.xyz(rgb);
	  let x = xyz[0];
	  let y = xyz[1];
	  let z = xyz[2];
	  x /= 95.047;
	  y /= 100;
	  z /= 108.883;
	  x = x > LAB_FT ? x ** (1 / 3) : 7.787 * x + 16 / 116;
	  y = y > LAB_FT ? y ** (1 / 3) : 7.787 * y + 16 / 116;
	  z = z > LAB_FT ? z ** (1 / 3) : 7.787 * z + 16 / 116;
	  const l = 116 * y - 16;
	  const a = 500 * (x - y);
	  const b = 200 * (y - z);
	  return [l, a, b];
	};
	convert.hsl.rgb = function(hsl) {
	  const h = hsl[0] / 360;
	  const s = hsl[1] / 100;
	  const l = hsl[2] / 100;
	  let t3;
	  let value;
	  if (s === 0) {
	    value = l * 255;
	    return [value, value, value];
	  }
	  const t2 = l < 0.5 ? l * (1 + s) : l + s - l * s;
	  const t1 = 2 * l - t2;
	  const rgb = [0, 0, 0];
	  for (let i = 0; i < 3; i++) {
	    t3 = h + 1 / 3 * -(i - 1);
	    if (t3 < 0) {
	      t3++;
	    }
	    if (t3 > 1) {
	      t3--;
	    }
	    if (6 * t3 < 1) {
	      value = t1 + (t2 - t1) * 6 * t3;
	    } else if (2 * t3 < 1) {
	      value = t2;
	    } else if (3 * t3 < 2) {
	      value = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
	    } else {
	      value = t1;
	    }
	    rgb[i] = value * 255;
	  }
	  return rgb;
	};
	convert.hsl.hsv = function(hsl) {
	  const h = hsl[0];
	  let s = hsl[1] / 100;
	  let l = hsl[2] / 100;
	  let smin = s;
	  const lmin = Math.max(l, 0.01);
	  l *= 2;
	  s *= l <= 1 ? l : 2 - l;
	  smin *= lmin <= 1 ? lmin : 2 - lmin;
	  const v = (l + s) / 2;
	  const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
	  return [h, sv * 100, v * 100];
	};
	convert.hsv.rgb = function(hsv) {
	  const h = hsv[0] / 60;
	  const s = hsv[1] / 100;
	  let v = hsv[2] / 100;
	  const hi = Math.floor(h) % 6;
	  const f = h - Math.floor(h);
	  const p = 255 * v * (1 - s);
	  const q = 255 * v * (1 - s * f);
	  const t = 255 * v * (1 - s * (1 - f));
	  v *= 255;
	  switch (hi) {
	    case 0: {
	      return [v, t, p];
	    }
	    case 1: {
	      return [q, v, p];
	    }
	    case 2: {
	      return [p, v, t];
	    }
	    case 3: {
	      return [p, q, v];
	    }
	    case 4: {
	      return [t, p, v];
	    }
	    case 5: {
	      return [v, p, q];
	    }
	  }
	};
	convert.hsv.hsl = function(hsv) {
	  const h = hsv[0];
	  const s = hsv[1] / 100;
	  const v = hsv[2] / 100;
	  const vmin = Math.max(v, 0.01);
	  let sl;
	  let l;
	  l = (2 - s) * v;
	  const lmin = (2 - s) * vmin;
	  sl = s * vmin;
	  sl /= lmin <= 1 ? lmin : 2 - lmin;
	  sl = sl || 0;
	  l /= 2;
	  return [h, sl * 100, l * 100];
	};
	convert.hwb.rgb = function(hwb) {
	  const h = hwb[0] / 360;
	  let wh = hwb[1] / 100;
	  let bl = hwb[2] / 100;
	  const ratio = wh + bl;
	  let f;
	  if (ratio > 1) {
	    wh /= ratio;
	    bl /= ratio;
	  }
	  const i = Math.floor(6 * h);
	  const v = 1 - bl;
	  f = 6 * h - i;
	  if ((i & 1) !== 0) {
	    f = 1 - f;
	  }
	  const n = wh + f * (v - wh);
	  let r;
	  let g;
	  let b;
	  switch (i) {
	    default:
	    case 6:
	    case 0: {
	      r = v;
	      g = n;
	      b = wh;
	      break;
	    }
	    case 1: {
	      r = n;
	      g = v;
	      b = wh;
	      break;
	    }
	    case 2: {
	      r = wh;
	      g = v;
	      b = n;
	      break;
	    }
	    case 3: {
	      r = wh;
	      g = n;
	      b = v;
	      break;
	    }
	    case 4: {
	      r = n;
	      g = wh;
	      b = v;
	      break;
	    }
	    case 5: {
	      r = v;
	      g = wh;
	      b = n;
	      break;
	    }
	  }
	  return [r * 255, g * 255, b * 255];
	};
	convert.cmyk.rgb = function(cmyk) {
	  const c = cmyk[0] / 100;
	  const m = cmyk[1] / 100;
	  const y = cmyk[2] / 100;
	  const k = cmyk[3] / 100;
	  const r = 1 - Math.min(1, c * (1 - k) + k);
	  const g = 1 - Math.min(1, m * (1 - k) + k);
	  const b = 1 - Math.min(1, y * (1 - k) + k);
	  return [r * 255, g * 255, b * 255];
	};
	convert.xyz.rgb = function(xyz) {
	  const x = xyz[0] / 100;
	  const y = xyz[1] / 100;
	  const z = xyz[2] / 100;
	  let r;
	  let g;
	  let b;
	  r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
	  g = x * -0.969266 + y * 1.8760108 + z * 0.041556;
	  b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
	  r = srgbNonlinearTransform(r);
	  g = srgbNonlinearTransform(g);
	  b = srgbNonlinearTransform(b);
	  return [r * 255, g * 255, b * 255];
	};
	convert.xyz.lab = function(xyz) {
	  let x = xyz[0];
	  let y = xyz[1];
	  let z = xyz[2];
	  x /= 95.047;
	  y /= 100;
	  z /= 108.883;
	  x = x > LAB_FT ? x ** (1 / 3) : 7.787 * x + 16 / 116;
	  y = y > LAB_FT ? y ** (1 / 3) : 7.787 * y + 16 / 116;
	  z = z > LAB_FT ? z ** (1 / 3) : 7.787 * z + 16 / 116;
	  const l = 116 * y - 16;
	  const a = 500 * (x - y);
	  const b = 200 * (y - z);
	  return [l, a, b];
	};
	convert.xyz.oklab = function(xyz) {
	  const x = xyz[0] / 100;
	  const y = xyz[1] / 100;
	  const z = xyz[2] / 100;
	  const lp = Math.cbrt(0.8189330101 * x + 0.3618667424 * y - 0.1288597137 * z);
	  const mp = Math.cbrt(0.0329845436 * x + 0.9293118715 * y + 0.0361456387 * z);
	  const sp = Math.cbrt(0.0482003018 * x + 0.2643662691 * y + 0.633851707 * z);
	  const l = 0.2104542553 * lp + 0.793617785 * mp - 0.0040720468 * sp;
	  const a = 1.9779984951 * lp - 2.428592205 * mp + 0.4505937099 * sp;
	  const b = 0.0259040371 * lp + 0.7827717662 * mp - 0.808675766 * sp;
	  return [l * 100, a * 100, b * 100];
	};
	convert.oklab.oklch = function(oklab) {
	  return convert.lab.lch(oklab);
	};
	convert.oklab.xyz = function(oklab) {
	  const ll = oklab[0] / 100;
	  const a = oklab[1] / 100;
	  const b = oklab[2] / 100;
	  const l = (0.999999998 * ll + 0.396337792 * a + 0.215803758 * b) ** 3;
	  const m = (1.000000008 * ll - 0.105561342 * a - 0.063854175 * b) ** 3;
	  const s = (1.000000055 * ll - 0.089484182 * a - 1.291485538 * b) ** 3;
	  const x = 1.227013851 * l - 0.55779998 * m + 0.281256149 * s;
	  const y = -0.040580178 * l + 1.11225687 * m - 0.071676679 * s;
	  const z = -0.076381285 * l - 0.421481978 * m + 1.58616322 * s;
	  return [x * 100, y * 100, z * 100];
	};
	convert.oklab.rgb = function(oklab) {
	  const ll = oklab[0] / 100;
	  const aa = oklab[1] / 100;
	  const bb = oklab[2] / 100;
	  const l = (ll + 0.3963377774 * aa + 0.2158037573 * bb) ** 3;
	  const m = (ll - 0.1055613458 * aa - 0.0638541728 * bb) ** 3;
	  const s = (ll - 0.0894841775 * aa - 1.291485548 * bb) ** 3;
	  const r = srgbNonlinearTransform(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s);
	  const g = srgbNonlinearTransform(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s);
	  const b = srgbNonlinearTransform(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s);
	  return [r * 255, g * 255, b * 255];
	};
	convert.oklch.oklab = function(oklch) {
	  return convert.lch.lab(oklch);
	};
	convert.lab.xyz = function(lab) {
	  const l = lab[0];
	  const a = lab[1];
	  const b = lab[2];
	  let x;
	  let y;
	  let z;
	  y = (l + 16) / 116;
	  x = a / 500 + y;
	  z = y - b / 200;
	  const y2 = y ** 3;
	  const x2 = x ** 3;
	  const z2 = z ** 3;
	  y = y2 > LAB_FT ? y2 : (y - 16 / 116) / 7.787;
	  x = x2 > LAB_FT ? x2 : (x - 16 / 116) / 7.787;
	  z = z2 > LAB_FT ? z2 : (z - 16 / 116) / 7.787;
	  x *= 95.047;
	  y *= 100;
	  z *= 108.883;
	  return [x, y, z];
	};
	convert.lab.lch = function(lab) {
	  const l = lab[0];
	  const a = lab[1];
	  const b = lab[2];
	  let h;
	  const hr = Math.atan2(b, a);
	  h = hr * 360 / 2 / Math.PI;
	  if (h < 0) {
	    h += 360;
	  }
	  const c = Math.sqrt(a * a + b * b);
	  return [l, c, h];
	};
	convert.lch.lab = function(lch) {
	  const l = lch[0];
	  const c = lch[1];
	  const h = lch[2];
	  const hr = h / 360 * 2 * Math.PI;
	  const a = c * Math.cos(hr);
	  const b = c * Math.sin(hr);
	  return [l, a, b];
	};
	convert.rgb.ansi16 = function(args, saturation = null) {
	  const [r, g, b] = args;
	  let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
	  value = Math.round(value / 50);
	  if (value === 0) {
	    return 30;
	  }
	  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
	  if (value === 2) {
	    ansi += 60;
	  }
	  return ansi;
	};
	convert.hsv.ansi16 = function(args) {
	  return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
	};
	convert.rgb.ansi256 = function(args) {
	  const r = args[0];
	  const g = args[1];
	  const b = args[2];
	  if (r >> 4 === g >> 4 && g >> 4 === b >> 4) {
	    if (r < 8) {
	      return 16;
	    }
	    if (r > 248) {
	      return 231;
	    }
	    return Math.round((r - 8) / 247 * 24) + 232;
	  }
	  const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
	  return ansi;
	};
	convert.ansi16.rgb = function(args) {
	  args = args[0];
	  let color = args % 10;
	  if (color === 0 || color === 7) {
	    if (args > 50) {
	      color += 3.5;
	    }
	    color = color / 10.5 * 255;
	    return [color, color, color];
	  }
	  const mult = (Math.trunc(args > 50) + 1) * 0.5;
	  const r = (color & 1) * mult * 255;
	  const g = (color >> 1 & 1) * mult * 255;
	  const b = (color >> 2 & 1) * mult * 255;
	  return [r, g, b];
	};
	convert.ansi256.rgb = function(args) {
	  args = args[0];
	  if (args >= 232) {
	    const c = (args - 232) * 10 + 8;
	    return [c, c, c];
	  }
	  args -= 16;
	  let rem;
	  const r = Math.floor(args / 36) / 5 * 255;
	  const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
	  const b = rem % 6 / 5 * 255;
	  return [r, g, b];
	};
	convert.rgb.hex = function(args) {
	  const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
	  const string = integer.toString(16).toUpperCase();
	  return "000000".slice(string.length) + string;
	};
	convert.hex.rgb = function(args) {
	  const match = args.toString(16).match(/[a-f\d]{6}|[a-f\d]{3}/i);
	  if (!match) {
	    return [0, 0, 0];
	  }
	  let colorString = match[0];
	  if (match[0].length === 3) {
	    colorString = [...colorString].map((char) => char + char).join("");
	  }
	  const integer = Number.parseInt(colorString, 16);
	  const r = integer >> 16 & 255;
	  const g = integer >> 8 & 255;
	  const b = integer & 255;
	  return [r, g, b];
	};
	convert.rgb.hcg = function(rgb) {
	  const r = rgb[0] / 255;
	  const g = rgb[1] / 255;
	  const b = rgb[2] / 255;
	  const max = Math.max(Math.max(r, g), b);
	  const min = Math.min(Math.min(r, g), b);
	  const chroma = max - min;
	  let hue;
	  const grayscale = chroma < 1 ? min / (1 - chroma) : 0;
	  if (chroma <= 0) {
	    hue = 0;
	  } else if (max === r) {
	    hue = (g - b) / chroma % 6;
	  } else if (max === g) {
	    hue = 2 + (b - r) / chroma;
	  } else {
	    hue = 4 + (r - g) / chroma;
	  }
	  hue /= 6;
	  hue %= 1;
	  return [hue * 360, chroma * 100, grayscale * 100];
	};
	convert.hsl.hcg = function(hsl) {
	  const s = hsl[1] / 100;
	  const l = hsl[2] / 100;
	  const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
	  let f = 0;
	  if (c < 1) {
	    f = (l - 0.5 * c) / (1 - c);
	  }
	  return [hsl[0], c * 100, f * 100];
	};
	convert.hsv.hcg = function(hsv) {
	  const s = hsv[1] / 100;
	  const v = hsv[2] / 100;
	  const c = s * v;
	  let f = 0;
	  if (c < 1) {
	    f = (v - c) / (1 - c);
	  }
	  return [hsv[0], c * 100, f * 100];
	};
	convert.hcg.rgb = function(hcg) {
	  const h = hcg[0] / 360;
	  const c = hcg[1] / 100;
	  const g = hcg[2] / 100;
	  if (c === 0) {
	    return [g * 255, g * 255, g * 255];
	  }
	  const pure = [0, 0, 0];
	  const hi = h % 1 * 6;
	  const v = hi % 1;
	  const w = 1 - v;
	  let mg = 0;
	  switch (Math.floor(hi)) {
	    case 0: {
	      pure[0] = 1;
	      pure[1] = v;
	      pure[2] = 0;
	      break;
	    }
	    case 1: {
	      pure[0] = w;
	      pure[1] = 1;
	      pure[2] = 0;
	      break;
	    }
	    case 2: {
	      pure[0] = 0;
	      pure[1] = 1;
	      pure[2] = v;
	      break;
	    }
	    case 3: {
	      pure[0] = 0;
	      pure[1] = w;
	      pure[2] = 1;
	      break;
	    }
	    case 4: {
	      pure[0] = v;
	      pure[1] = 0;
	      pure[2] = 1;
	      break;
	    }
	    default: {
	      pure[0] = 1;
	      pure[1] = 0;
	      pure[2] = w;
	    }
	  }
	  mg = (1 - c) * g;
	  return [
	    (c * pure[0] + mg) * 255,
	    (c * pure[1] + mg) * 255,
	    (c * pure[2] + mg) * 255
	  ];
	};
	convert.hcg.hsv = function(hcg) {
	  const c = hcg[1] / 100;
	  const g = hcg[2] / 100;
	  const v = c + g * (1 - c);
	  let f = 0;
	  if (v > 0) {
	    f = c / v;
	  }
	  return [hcg[0], f * 100, v * 100];
	};
	convert.hcg.hsl = function(hcg) {
	  const c = hcg[1] / 100;
	  const g = hcg[2] / 100;
	  const l = g * (1 - c) + 0.5 * c;
	  let s = 0;
	  if (l > 0 && l < 0.5) {
	    s = c / (2 * l);
	  } else if (l >= 0.5 && l < 1) {
	    s = c / (2 * (1 - l));
	  }
	  return [hcg[0], s * 100, l * 100];
	};
	convert.hcg.hwb = function(hcg) {
	  const c = hcg[1] / 100;
	  const g = hcg[2] / 100;
	  const v = c + g * (1 - c);
	  return [hcg[0], (v - c) * 100, (1 - v) * 100];
	};
	convert.hwb.hcg = function(hwb) {
	  const w = hwb[1] / 100;
	  const b = hwb[2] / 100;
	  const v = 1 - b;
	  const c = v - w;
	  let g = 0;
	  if (c < 1) {
	    g = (v - c) / (1 - c);
	  }
	  return [hwb[0], c * 100, g * 100];
	};
	convert.apple.rgb = function(apple) {
	  return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
	};
	convert.rgb.apple = function(rgb) {
	  return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
	};
	convert.gray.rgb = function(args) {
	  return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
	};
	convert.gray.hsl = function(args) {
	  return [0, 0, args[0]];
	};
	convert.gray.hsv = convert.gray.hsl;
	convert.gray.hwb = function(gray) {
	  return [0, 100, gray[0]];
	};
	convert.gray.cmyk = function(gray) {
	  return [0, 0, 0, gray[0]];
	};
	convert.gray.lab = function(gray) {
	  return [gray[0], 0, 0];
	};
	convert.gray.hex = function(gray) {
	  const value = Math.round(gray[0] / 100 * 255) & 255;
	  const integer = (value << 16) + (value << 8) + value;
	  const string = integer.toString(16).toUpperCase();
	  return "000000".slice(string.length) + string;
	};
	convert.rgb.gray = function(rgb) {
	  const value = (rgb[0] + rgb[1] + rgb[2]) / 3;
	  return [value / 255 * 100];
	};

	// node_modules/color-convert/route.js
	function buildGraph() {
	  const graph = {};
	  const models2 = Object.keys(conversions_default);
	  for (let { length } = models2, i = 0; i < length; i++) {
	    graph[models2[i]] = {
	      // http://jsperf.com/1-vs-infinity
	      // micro-opt, but this is simple.
	      distance: -1,
	      parent: null
	    };
	  }
	  return graph;
	}
	function deriveBFS(fromModel) {
	  const graph = buildGraph();
	  const queue = [fromModel];
	  graph[fromModel].distance = 0;
	  while (queue.length > 0) {
	    const current = queue.pop();
	    const adjacents = Object.keys(conversions_default[current]);
	    for (let { length } = adjacents, i = 0; i < length; i++) {
	      const adjacent = adjacents[i];
	      const node = graph[adjacent];
	      if (node.distance === -1) {
	        node.distance = graph[current].distance + 1;
	        node.parent = current;
	        queue.unshift(adjacent);
	      }
	    }
	  }
	  return graph;
	}
	function link(from, to) {
	  return function(args) {
	    return to(from(args));
	  };
	}
	function wrapConversion(toModel, graph) {
	  const path = [graph[toModel].parent, toModel];
	  let fn = conversions_default[graph[toModel].parent][toModel];
	  let cur = graph[toModel].parent;
	  while (graph[cur].parent) {
	    path.unshift(graph[cur].parent);
	    fn = link(conversions_default[graph[cur].parent][cur], fn);
	    cur = graph[cur].parent;
	  }
	  fn.conversion = path;
	  return fn;
	}
	function route(fromModel) {
	  const graph = deriveBFS(fromModel);
	  const conversion = {};
	  const models2 = Object.keys(graph);
	  for (let { length } = models2, i = 0; i < length; i++) {
	    const toModel = models2[i];
	    const node = graph[toModel];
	    if (node.parent === null) {
	      continue;
	    }
	    conversion[toModel] = wrapConversion(toModel, graph);
	  }
	  return conversion;
	}
	var route_default = route;

	// node_modules/color-convert/index.js
	var convert2 = {};
	var models = Object.keys(conversions_default);
	function wrapRaw(fn) {
	  const wrappedFn = function(...args) {
	    const arg0 = args[0];
	    if (arg0 === void 0 || arg0 === null) {
	      return arg0;
	    }
	    if (arg0.length > 1) {
	      args = arg0;
	    }
	    return fn(args);
	  };
	  if ("conversion" in fn) {
	    wrappedFn.conversion = fn.conversion;
	  }
	  return wrappedFn;
	}
	function wrapRounded(fn) {
	  const wrappedFn = function(...args) {
	    const arg0 = args[0];
	    if (arg0 === void 0 || arg0 === null) {
	      return arg0;
	    }
	    if (arg0.length > 1) {
	      args = arg0;
	    }
	    const result = fn(args);
	    if (typeof result === "object") {
	      for (let { length } = result, i = 0; i < length; i++) {
	        result[i] = Math.round(result[i]);
	      }
	    }
	    return result;
	  };
	  if ("conversion" in fn) {
	    wrappedFn.conversion = fn.conversion;
	  }
	  return wrappedFn;
	}
	for (const fromModel of models) {
	  convert2[fromModel] = {};
	  Object.defineProperty(convert2[fromModel], "channels", { value: conversions_default[fromModel].channels });
	  Object.defineProperty(convert2[fromModel], "labels", { value: conversions_default[fromModel].labels });
	  const routes = route_default(fromModel);
	  const routeModels = Object.keys(routes);
	  for (const toModel of routeModels) {
	    const fn = routes[toModel];
	    convert2[fromModel][toModel] = wrapRounded(fn);
	    convert2[fromModel][toModel].raw = wrapRaw(fn);
	  }
	}
	var color_convert_default = convert2;

	// node_modules/color/index.js
	var skippedModels = [
	  // To be honest, I don't really feel like keyword belongs in color convert, but eh.
	  "keyword",
	  // Gray conflicts with some method names, and has its own method defined.
	  "gray",
	  // Shouldn't really be in color-convert either...
	  "hex"
	];
	var hashedModelKeys = {};
	for (const model of Object.keys(color_convert_default)) {
	  hashedModelKeys[[...color_convert_default[model].labels].sort().join("")] = model;
	}
	var limiters = {};
	function Color(object, model) {
	  if (!(this instanceof Color)) {
	    return new Color(object, model);
	  }
	  if (model && model in skippedModels) {
	    model = null;
	  }
	  if (model && !(model in color_convert_default)) {
	    throw new Error("Unknown model: " + model);
	  }
	  let i;
	  let channels;
	  if (object == null) {
	    this.model = "rgb";
	    this.color = [0, 0, 0];
	    this.valpha = 1;
	  } else if (object instanceof Color) {
	    this.model = object.model;
	    this.color = [...object.color];
	    this.valpha = object.valpha;
	  } else if (typeof object === "string") {
	    const result = color_string_default.get(object);
	    if (result === null) {
	      throw new Error("Unable to parse color from string: " + object);
	    }
	    this.model = result.model;
	    channels = color_convert_default[this.model].channels;
	    this.color = result.value.slice(0, channels);
	    this.valpha = typeof result.value[channels] === "number" ? result.value[channels] : 1;
	  } else if (object.length > 0) {
	    this.model = model || "rgb";
	    channels = color_convert_default[this.model].channels;
	    const newArray = Array.prototype.slice.call(object, 0, channels);
	    this.color = zeroArray(newArray, channels);
	    this.valpha = typeof object[channels] === "number" ? object[channels] : 1;
	  } else if (typeof object === "number") {
	    this.model = "rgb";
	    this.color = [
	      object >> 16 & 255,
	      object >> 8 & 255,
	      object & 255
	    ];
	    this.valpha = 1;
	  } else {
	    this.valpha = 1;
	    const keys = Object.keys(object);
	    if ("alpha" in object) {
	      keys.splice(keys.indexOf("alpha"), 1);
	      this.valpha = typeof object.alpha === "number" ? object.alpha : 0;
	    }
	    const hashedKeys = keys.sort().join("");
	    if (!(hashedKeys in hashedModelKeys)) {
	      throw new Error("Unable to parse color from object: " + JSON.stringify(object));
	    }
	    this.model = hashedModelKeys[hashedKeys];
	    const { labels } = color_convert_default[this.model];
	    const color = [];
	    for (i = 0; i < labels.length; i++) {
	      color.push(object[labels[i]]);
	    }
	    this.color = zeroArray(color);
	  }
	  if (limiters[this.model]) {
	    channels = color_convert_default[this.model].channels;
	    for (i = 0; i < channels; i++) {
	      const limit = limiters[this.model][i];
	      if (limit) {
	        this.color[i] = limit(this.color[i]);
	      }
	    }
	  }
	  this.valpha = Math.max(0, Math.min(1, this.valpha));
	  if (Object.freeze) {
	    Object.freeze(this);
	  }
	}
	Color.prototype = {
	  toString() {
	    return this.string();
	  },
	  toJSON() {
	    return this[this.model]();
	  },
	  string(places) {
	    let self = this.model in color_string_default.to ? this : this.rgb();
	    self = self.round(typeof places === "number" ? places : 1);
	    const arguments_ = self.valpha === 1 ? self.color : [...self.color, this.valpha];
	    return color_string_default.to[self.model](...arguments_);
	  },
	  percentString(places) {
	    const self = this.rgb().round(typeof places === "number" ? places : 1);
	    const arguments_ = self.valpha === 1 ? self.color : [...self.color, this.valpha];
	    return color_string_default.to.rgb.percent(...arguments_);
	  },
	  array() {
	    return this.valpha === 1 ? [...this.color] : [...this.color, this.valpha];
	  },
	  object() {
	    const result = {};
	    const { channels } = color_convert_default[this.model];
	    const { labels } = color_convert_default[this.model];
	    for (let i = 0; i < channels; i++) {
	      result[labels[i]] = this.color[i];
	    }
	    if (this.valpha !== 1) {
	      result.alpha = this.valpha;
	    }
	    return result;
	  },
	  unitArray() {
	    const rgb = this.rgb().color;
	    rgb[0] /= 255;
	    rgb[1] /= 255;
	    rgb[2] /= 255;
	    if (this.valpha !== 1) {
	      rgb.push(this.valpha);
	    }
	    return rgb;
	  },
	  unitObject() {
	    const rgb = this.rgb().object();
	    rgb.r /= 255;
	    rgb.g /= 255;
	    rgb.b /= 255;
	    if (this.valpha !== 1) {
	      rgb.alpha = this.valpha;
	    }
	    return rgb;
	  },
	  round(places) {
	    places = Math.max(places || 0, 0);
	    return new Color([...this.color.map(roundToPlace(places)), this.valpha], this.model);
	  },
	  alpha(value) {
	    if (value !== void 0) {
	      return new Color([...this.color, Math.max(0, Math.min(1, value))], this.model);
	    }
	    return this.valpha;
	  },
	  // Rgb
	  red: getset("rgb", 0, maxfn(255)),
	  green: getset("rgb", 1, maxfn(255)),
	  blue: getset("rgb", 2, maxfn(255)),
	  hue: getset(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, (value) => (value % 360 + 360) % 360),
	  saturationl: getset("hsl", 1, maxfn(100)),
	  lightness: getset("hsl", 2, maxfn(100)),
	  saturationv: getset("hsv", 1, maxfn(100)),
	  value: getset("hsv", 2, maxfn(100)),
	  chroma: getset("hcg", 1, maxfn(100)),
	  gray: getset("hcg", 2, maxfn(100)),
	  white: getset("hwb", 1, maxfn(100)),
	  wblack: getset("hwb", 2, maxfn(100)),
	  cyan: getset("cmyk", 0, maxfn(100)),
	  magenta: getset("cmyk", 1, maxfn(100)),
	  yellow: getset("cmyk", 2, maxfn(100)),
	  black: getset("cmyk", 3, maxfn(100)),
	  x: getset("xyz", 0, maxfn(95.047)),
	  y: getset("xyz", 1, maxfn(100)),
	  z: getset("xyz", 2, maxfn(108.833)),
	  l: getset("lab", 0, maxfn(100)),
	  a: getset("lab", 1),
	  b: getset("lab", 2),
	  keyword(value) {
	    if (value !== void 0) {
	      return new Color(value);
	    }
	    return color_convert_default[this.model].keyword(this.color);
	  },
	  hex(value) {
	    if (value !== void 0) {
	      return new Color(value);
	    }
	    return color_string_default.to.hex(...this.rgb().round().color);
	  },
	  hexa(value) {
	    if (value !== void 0) {
	      return new Color(value);
	    }
	    const rgbArray = this.rgb().round().color;
	    let alphaHex = Math.round(this.valpha * 255).toString(16).toUpperCase();
	    if (alphaHex.length === 1) {
	      alphaHex = "0" + alphaHex;
	    }
	    return color_string_default.to.hex(...rgbArray) + alphaHex;
	  },
	  rgbNumber() {
	    const rgb = this.rgb().color;
	    return (rgb[0] & 255) << 16 | (rgb[1] & 255) << 8 | rgb[2] & 255;
	  },
	  luminosity() {
	    const rgb = this.rgb().color;
	    const lum = [];
	    for (const [i, element] of rgb.entries()) {
	      const chan = element / 255;
	      lum[i] = chan <= 0.04045 ? chan / 12.92 : ((chan + 0.055) / 1.055) ** 2.4;
	    }
	    return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
	  },
	  contrast(color2) {
	    const lum1 = this.luminosity();
	    const lum2 = color2.luminosity();
	    if (lum1 > lum2) {
	      return (lum1 + 0.05) / (lum2 + 0.05);
	    }
	    return (lum2 + 0.05) / (lum1 + 0.05);
	  },
	  level(color2) {
	    const contrastRatio = this.contrast(color2);
	    if (contrastRatio >= 7) {
	      return "AAA";
	    }
	    return contrastRatio >= 4.5 ? "AA" : "";
	  },
	  isDark() {
	    const rgb = this.rgb().color;
	    const yiq = (rgb[0] * 2126 + rgb[1] * 7152 + rgb[2] * 722) / 1e4;
	    return yiq < 128;
	  },
	  isLight() {
	    return !this.isDark();
	  },
	  negate() {
	    const rgb = this.rgb();
	    for (let i = 0; i < 3; i++) {
	      rgb.color[i] = 255 - rgb.color[i];
	    }
	    return rgb;
	  },
	  lighten(ratio) {
	    const hsl = this.hsl();
	    hsl.color[2] += hsl.color[2] * ratio;
	    return hsl;
	  },
	  darken(ratio) {
	    const hsl = this.hsl();
	    hsl.color[2] -= hsl.color[2] * ratio;
	    return hsl;
	  },
	  saturate(ratio) {
	    const hsl = this.hsl();
	    hsl.color[1] += hsl.color[1] * ratio;
	    return hsl;
	  },
	  desaturate(ratio) {
	    const hsl = this.hsl();
	    hsl.color[1] -= hsl.color[1] * ratio;
	    return hsl;
	  },
	  whiten(ratio) {
	    const hwb = this.hwb();
	    hwb.color[1] += hwb.color[1] * ratio;
	    return hwb;
	  },
	  blacken(ratio) {
	    const hwb = this.hwb();
	    hwb.color[2] += hwb.color[2] * ratio;
	    return hwb;
	  },
	  grayscale() {
	    const rgb = this.rgb().color;
	    const value = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
	    return Color.rgb(value, value, value);
	  },
	  fade(ratio) {
	    return this.alpha(this.valpha - this.valpha * ratio);
	  },
	  opaquer(ratio) {
	    return this.alpha(this.valpha + this.valpha * ratio);
	  },
	  rotate(degrees) {
	    const hsl = this.hsl();
	    let hue = hsl.color[0];
	    hue = (hue + degrees) % 360;
	    hue = hue < 0 ? 360 + hue : hue;
	    hsl.color[0] = hue;
	    return hsl;
	  },
	  mix(mixinColor, weight) {
	    if (!mixinColor || !mixinColor.rgb) {
	      throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
	    }
	    const color1 = mixinColor.rgb();
	    const color2 = this.rgb();
	    const p = weight === void 0 ? 0.5 : weight;
	    const w = 2 * p - 1;
	    const a = color1.alpha() - color2.alpha();
	    const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2;
	    const w2 = 1 - w1;
	    return Color.rgb(
	      w1 * color1.red() + w2 * color2.red(),
	      w1 * color1.green() + w2 * color2.green(),
	      w1 * color1.blue() + w2 * color2.blue(),
	      color1.alpha() * p + color2.alpha() * (1 - p)
	    );
	  }
	};
	for (const model of Object.keys(color_convert_default)) {
	  if (skippedModels.includes(model)) {
	    continue;
	  }
	  const { channels } = color_convert_default[model];
	  Color.prototype[model] = function(...arguments_) {
	    if (this.model === model) {
	      return new Color(this);
	    }
	    if (arguments_.length > 0) {
	      return new Color(arguments_, model);
	    }
	    return new Color([...assertArray(color_convert_default[this.model][model].raw(this.color)), this.valpha], model);
	  };
	  Color[model] = function(...arguments_) {
	    let color = arguments_[0];
	    if (typeof color === "number") {
	      color = zeroArray(arguments_, channels);
	    }
	    return new Color(color, model);
	  };
	}
	function roundTo(number, places) {
	  return Number(number.toFixed(places));
	}
	function roundToPlace(places) {
	  return function(number) {
	    return roundTo(number, places);
	  };
	}
	function getset(model, channel, modifier) {
	  model = Array.isArray(model) ? model : [model];
	  for (const m of model) {
	    (limiters[m] ||= [])[channel] = modifier;
	  }
	  model = model[0];
	  return function(value) {
	    let result;
	    if (value !== void 0) {
	      if (modifier) {
	        value = modifier(value);
	      }
	      result = this[model]();
	      result.color[channel] = value;
	      return result;
	    }
	    result = this[model]().color[channel];
	    if (modifier) {
	      result = modifier(result);
	    }
	    return result;
	  };
	}
	function maxfn(max) {
	  return function(v) {
	    return Math.max(0, Math.min(max, v));
	  };
	}
	function assertArray(value) {
	  return Array.isArray(value) ? value : [value];
	}
	function zeroArray(array, length) {
	  for (let i = 0; i < length; i++) {
	    if (typeof array[i] !== "number") {
	      array[i] = 0;
	    }
	  }
	  return array;
	}
	var index_default = Color;
	return color;
}

var colour$1;
var hasRequiredColour$1;

function requireColour$1 () {
	if (hasRequiredColour$1) return colour$1;
	hasRequiredColour$1 = 1;
	colour$1 = requireColor().default;
	return colour$1;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var colour;
var hasRequiredColour;

function requireColour () {
	if (hasRequiredColour) return colour;
	hasRequiredColour = 1;
	const color = requireColour$1();
	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://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
	 */
	colour = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    // Public
	    tint,
	    greyscale,
	    grayscale,
	    pipelineColourspace,
	    pipelineColorspace,
	    toColourspace,
	    toColorspace,
	    // Private
	    _getBackgroundColourOption,
	    _setBackgroundColourOption
	  });
	  // Class attributes
	  Sharp.colourspace = colourspace;
	  Sharp.colorspace = colourspace;
	};
	return colour;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

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.
	 *
	 * 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
	 */
	channel = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    // Public instance functions
	    removeAlpha,
	    ensureAlpha,
	    extractChannel,
	    joinChannel,
	    bandbool
	  });
	  // Class attributes
	  Sharp.bool = bool;
	};
	return channel;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var output;
var hasRequiredOutput;

function requireOutput () {
	if (hasRequiredOutput) return output;
	hasRequiredOutput = 1;
	const path = nodePath;
	const is = requireIs();
	const sharp = requireSharp();

	const formats = new Map([
	  ['heic', 'heif'],
	  ['heif', 'heif'],
	  ['avif', 'avif'],
	  ['jpeg', 'jpeg'],
	  ['jpg', 'jpeg'],
	  ['jpe', 'jpeg'],
	  ['tile', 'tile'],
	  ['dz', 'tile'],
	  ['png', 'png'],
	  ['raw', 'raw'],
	  ['tiff', 'tiff'],
	  ['tif', 'tiff'],
	  ['webp', 'webp'],
	  ['gif', 'gif'],
	  ['jp2', 'jp2'],
	  ['jpx', 'jp2'],
	  ['j2k', 'jp2'],
	  ['j2c', 'jp2'],
	  ['jxl', 'jxl']
	]);

	const jp2Regex = /\.(jp[2x]|j2[kc])$/i;

	const errJp2Save = () => new Error('JP2 output requires libvips with support for OpenJPEG');

	const bitdepthFromColourCount = (colours) => 1 << 31 - Math.clz32(Math.ceil(Math.log2(colours)));

	/**
	 * Write output image data to a file.
	 *
	 * If an explicit output format is not selected, it will be inferred from the extension,
	 * with JPEG, PNG, WebP, AVIF, TIFF, GIF, DZI, and libvips' V format supported.
	 * Note that raw pixel data is only supported for buffer output.
	 *
	 * By default all metadata will be removed, which includes EXIF-based orientation.
	 * See {@link #withmetadata withMetadata} for control over this.
	 *
	 * The caller is responsible for ensuring directory structures and permissions exist.
	 *
	 * A `Promise` is returned when `callback` is not provided.
	 *
	 * @example
	 * sharp(input)
	 *   .toFile('output.png', (err, info) => { ... });
	 *
	 * @example
	 * sharp(input)
	 *   .toFile('output.png')
	 *   .then(info => { ... })
	 *   .catch(err => { ... });
	 *
	 * @param {string} fileOut - the path to write the image data to.
	 * @param {Function} [callback] - called on completion with two arguments `(err, info)`.
	 * `info` contains the output image `format`, `size` (bytes), `width`, `height`,
	 * `channels` and `premultiplied` (indicating if premultiplication was used).
	 * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
	 * When using the attention crop strategy also contains `attentionX` and `attentionY`, the focal point of the cropped region.
	 * Animated output will also contain `pageHeight` and `pages`.
	 * May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
	 * @returns {Promise<Object>} - when no callback is provided
	 * @throws {Error} Invalid parameters
	 */
	function toFile (fileOut, callback) {
	  let err;
	  if (!is.string(fileOut)) {
	    err = new Error('Missing output file path');
	  } else if (is.string(this.options.input.file) && path.resolve(this.options.input.file) === path.resolve(fileOut)) {
	    err = new Error('Cannot use same file for input and output');
	  } else if (jp2Regex.test(path.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
	    err = errJp2Save();
	  }
	  if (err) {
	    if (is.fn(callback)) {
	      callback(err);
	    } else {
	      return Promise.reject(err);
	    }
	  } else {
	    this.options.fileOut = fileOut;
	    const stack = Error();
	    return this._pipeline(callback, stack);
	  }
	  return this;
	}

	/**
	 * Write output to a Buffer.
	 * JPEG, PNG, WebP, AVIF, TIFF, GIF and raw pixel data output are supported.
	 *
	 * Use {@link #toformat toFormat} or one of the format-specific functions such as {@link #jpeg jpeg}, {@link #png png} etc. to set the output format.
	 *
	 * If no explicit format is set, the output format will match the input image, except SVG input which becomes PNG output.
	 *
	 * By default all metadata will be removed, which includes EXIF-based orientation.
	 * See {@link #withmetadata withMetadata} for control over this.
	 *
	 * `callback`, if present, gets three arguments `(err, data, info)` where:
	 * - `err` is an error, if any.
	 * - `data` is the output image data.
	 * - `info` contains the output image `format`, `size` (bytes), `width`, `height`,
	 * `channels` and `premultiplied` (indicating if premultiplication was used).
	 * When using a crop strategy also contains `cropOffsetLeft` and `cropOffsetTop`.
	 * Animated output will also contain `pageHeight` and `pages`.
	 * May also contain `textAutofitDpi` (dpi the font was rendered at) if image was created from text.
	 *
	 * A `Promise` is returned when `callback` is not provided.
	 *
	 * @example
	 * sharp(input)
	 *   .toBuffer((err, data, info) => { ... });
	 *
	 * @example
	 * sharp(input)
	 *   .toBuffer()
	 *   .then(data => { ... })
	 *   .catch(err => { ... });
	 *
	 * @example
	 * sharp(input)
	 *   .png()
	 *   .toBuffer({ resolveWithObject: true })
	 *   .then(({ data, info }) => { ... })
	 *   .catch(err => { ... });
	 *
	 * @example
	 * const { data, info } = await sharp('my-image.jpg')
	 *   // output the raw pixels
	 *   .raw()
	 *   .toBuffer({ resolveWithObject: true });
	 *
	 * // create a more type safe way to work with the raw pixel data
	 * // this will not copy the data, instead it will change `data`s underlying ArrayBuffer
	 * // so `data` and `pixelArray` point to the same memory location
	 * const pixelArray = new Uint8ClampedArray(data.buffer);
	 *
	 * // When you are done changing the pixelArray, sharp takes the `pixelArray` as an input
	 * const { width, height, channels } = info;
	 * await sharp(pixelArray, { raw: { width, height, channels } })
	 *   .toFile('my-changed-image.jpg');
	 *
	 * @param {Object} [options]
	 * @param {boolean} [options.resolveWithObject] Resolve the Promise with an Object containing `data` and `info` properties instead of resolving only with `data`.
	 * @param {Function} [callback]
	 * @returns {Promise<Buffer>} - when no callback is provided
	 */
	function toBuffer (options, callback) {
	  if (is.object(options)) {
	    this._setBooleanOption('resolveWithObject', options.resolveWithObject);
	  } else if (this.options.resolveWithObject) {
	    this.options.resolveWithObject = false;
	  }
	  this.options.fileOut = '';
	  const stack = Error();
	  return this._pipeline(is.fn(options) ? options : callback, stack);
	}

	/**
	 * Keep all EXIF metadata from the input image in the output image.
	 *
	 * EXIF metadata is unsupported for TIFF output.
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const outputWithExif = await sharp(inputWithExif)
	 *   .keepExif()
	 *   .toBuffer();
	 *
	 * @returns {Sharp}
	 */
	function keepExif () {
	  this.options.keepMetadata |= 0b00001;
	  return this;
	}

	/**
	 * Set EXIF metadata in the output image, ignoring any EXIF in the input image.
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const dataWithExif = await sharp(input)
	 *   .withExif({
	 *     IFD0: {
	 *       Copyright: 'The National Gallery'
	 *     },
	 *     IFD3: {
	 *       GPSLatitudeRef: 'N',
	 *       GPSLatitude: '51/1 30/1 3230/100',
	 *       GPSLongitudeRef: 'W',
	 *       GPSLongitude: '0/1 7/1 4366/100'
	 *     }
	 *   })
	 *   .toBuffer();
	 *
	 * @param {Object<string, Object<string, string>>} exif Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function withExif (exif) {
	  if (is.object(exif)) {
	    for (const [ifd, entries] of Object.entries(exif)) {
	      if (is.object(entries)) {
	        for (const [k, v] of Object.entries(entries)) {
	          if (is.string(v)) {
	            this.options.withExif[`exif-${ifd.toLowerCase()}-${k}`] = v;
	          } else {
	            throw is.invalidParameterError(`${ifd}.${k}`, 'string', v);
	          }
	        }
	      } else {
	        throw is.invalidParameterError(ifd, 'object', entries);
	      }
	    }
	  } else {
	    throw is.invalidParameterError('exif', 'object', exif);
	  }
	  this.options.withExifMerge = false;
	  return this.keepExif();
	}

	/**
	 * Update EXIF metadata from the input image in the output image.
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const dataWithMergedExif = await sharp(inputWithExif)
	 *   .withExifMerge({
	 *     IFD0: {
	 *       Copyright: 'The National Gallery'
	 *     }
	 *   })
	 *   .toBuffer();
	 *
	 * @param {Object<string, Object<string, string>>} exif Object keyed by IFD0, IFD1 etc. of key/value string pairs to write as EXIF data.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function withExifMerge (exif) {
	  this.withExif(exif);
	  this.options.withExifMerge = true;
	  return this;
	}

	/**
	 * Keep ICC profile from the input image in the output image.
	 *
	 * When input and output colour spaces differ, use with {@link /api-colour/#tocolourspace toColourspace} and optionally {@link /api-colour/#pipelinecolourspace pipelineColourspace}.
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const outputWithIccProfile = await sharp(inputWithIccProfile)
	 *   .keepIccProfile()
	 *   .toBuffer();
	 *
	 * @example
	 * const cmykOutputWithIccProfile = await sharp(cmykInputWithIccProfile)
	 *   .pipelineColourspace('cmyk')
	 *   .toColourspace('cmyk')
	 *   .keepIccProfile()
	 *   .toBuffer();
	 *
	 * @returns {Sharp}
	 */
	function keepIccProfile () {
	  this.options.keepMetadata |= 0b01000;
	  return this;
	}

	/**
	 * Transform using an ICC profile and attach to the output image.
	 *
	 * This can either be an absolute filesystem path or
	 * built-in profile name (`srgb`, `p3`, `cmyk`).
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const outputWithP3 = await sharp(input)
	 *   .withIccProfile('p3')
	 *   .toBuffer();
	 *
	 * @param {string} icc - Absolute filesystem path to output ICC profile or built-in profile name (srgb, p3, cmyk).
	 * @param {Object} [options]
	 * @param {number} [options.attach=true] Should the ICC profile be included in the output image metadata?
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function withIccProfile (icc, options) {
	  if (is.string(icc)) {
	    this.options.withIccProfile = icc;
	  } else {
	    throw is.invalidParameterError('icc', 'string', icc);
	  }
	  this.keepIccProfile();
	  if (is.object(options)) {
	    if (is.defined(options.attach)) {
	      if (is.bool(options.attach)) {
	        if (!options.attach) {
	          this.options.keepMetadata &= -9;
	        }
	      } else {
	        throw is.invalidParameterError('attach', 'boolean', options.attach);
	      }
	    }
	  }
	  return this;
	}

	/**
	 * Keep XMP metadata from the input image in the output image.
	 *
	 * @since 0.34.3
	 *
	 * @example
	 * const outputWithXmp = await sharp(inputWithXmp)
	 *   .keepXmp()
	 *   .toBuffer();
	 *
	 * @returns {Sharp}
	 */
	function keepXmp () {
	  this.options.keepMetadata |= 0b00010;
	  return this;
	}

	/**
	 * Set XMP metadata in the output image.
	 *
	 * Supported by PNG, JPEG, WebP, and TIFF output.
	 *
	 * @since 0.34.3
	 *
	 * @example
	 * const xmpString = `
	 *   <?xml version="1.0"?>
	 *   <x:xmpmeta xmlns:x="adobe:ns:meta/">
	 *     <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
	 *       <rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">
	 *         <dc:creator><rdf:Seq><rdf:li>John Doe</rdf:li></rdf:Seq></dc:creator>
	 *       </rdf:Description>
	 *     </rdf:RDF>
	 *   </x:xmpmeta>`;
	 *
	 * const data = await sharp(input)
	 *   .withXmp(xmpString)
	 *   .toBuffer();
	 *
	 * @param {string} xmp String containing XMP metadata to be embedded in the output image.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function withXmp (xmp) {
	  if (is.string(xmp) && xmp.length > 0) {
	    this.options.withXmp = xmp;
	    this.options.keepMetadata |= 0b00010;
	  } else {
	    throw is.invalidParameterError('xmp', 'non-empty string', xmp);
	  }
	  return this;
	}

	/**
	 * Keep all metadata (EXIF, ICC, XMP, IPTC) from the input image in the output image.
	 *
	 * The default behaviour, when `keepMetadata` is not used, is to convert to the device-independent
	 * sRGB colour space and strip all metadata, including the removal of any ICC profile.
	 *
	 * @since 0.33.0
	 *
	 * @example
	 * const outputWithMetadata = await sharp(inputWithMetadata)
	 *   .keepMetadata()
	 *   .toBuffer();
	 *
	 * @returns {Sharp}
	 */
	function keepMetadata () {
	  this.options.keepMetadata = 0b11111;
	  return this;
	}

	/**
	 * Keep most metadata (EXIF, XMP, IPTC) from the input image in the output image.
	 *
	 * This will also convert to and add a web-friendly sRGB ICC profile if appropriate.
	 *
	 * Allows orientation and density to be set or updated.
	 *
	 * @example
	 * const outputSrgbWithMetadata = await sharp(inputRgbWithMetadata)
	 *   .withMetadata()
	 *   .toBuffer();
	 *
	 * @example
	 * // Set output metadata to 96 DPI
	 * const data = await sharp(input)
	 *   .withMetadata({ density: 96 })
	 *   .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {number} [options.orientation] Used to update the EXIF `Orientation` tag, integer between 1 and 8.
	 * @param {number} [options.density] Number of pixels per inch (DPI).
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function withMetadata (options) {
	  this.keepMetadata();
	  this.withIccProfile('srgb');
	  if (is.object(options)) {
	    if (is.defined(options.orientation)) {
	      if (is.integer(options.orientation) && is.inRange(options.orientation, 1, 8)) {
	        this.options.withMetadataOrientation = options.orientation;
	      } else {
	        throw is.invalidParameterError('orientation', 'integer between 1 and 8', options.orientation);
	      }
	    }
	    if (is.defined(options.density)) {
	      if (is.number(options.density) && options.density > 0) {
	        this.options.withMetadataDensity = options.density;
	      } else {
	        throw is.invalidParameterError('density', 'positive number', options.density);
	      }
	    }
	    if (is.defined(options.icc)) {
	      this.withIccProfile(options.icc);
	    }
	    if (is.defined(options.exif)) {
	      this.withExifMerge(options.exif);
	    }
	  }
	  return this;
	}

	/**
	 * Force output to a given format.
	 *
	 * @example
	 * // Convert any input to PNG output
	 * const data = await sharp(input)
	 *   .toFormat('png')
	 *   .toBuffer();
	 *
	 * @param {(string|Object)} format - as a string or an Object with an 'id' attribute
	 * @param {Object} options - output options
	 * @returns {Sharp}
	 * @throws {Error} unsupported format or options
	 */
	function toFormat (format, options) {
	  const actualFormat = formats.get((is.object(format) && is.string(format.id) ? format.id : format).toLowerCase());
	  if (!actualFormat) {
	    throw is.invalidParameterError('format', `one of: ${[...formats.keys()].join(', ')}`, format);
	  }
	  return this[actualFormat](options);
	}

	/**
	 * Use these JPEG options for output image.
	 *
	 * @example
	 * // Convert any input to very high quality JPEG output
	 * const data = await sharp(input)
	 *   .jpeg({
	 *     quality: 100,
	 *     chromaSubsampling: '4:4:4'
	 *   })
	 *   .toBuffer();
	 *
	 * @example
	 * // Use mozjpeg to reduce output JPEG file size (slower)
	 * const data = await sharp(input)
	 *   .jpeg({ mozjpeg: true })
	 *   .toBuffer();
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.quality=80] - quality, integer 1-100
	 * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
	 * @param {string} [options.chromaSubsampling='4:2:0'] - set to '4:4:4' to prevent chroma subsampling otherwise defaults to '4:2:0' chroma subsampling
	 * @param {boolean} [options.optimiseCoding=true] - optimise Huffman coding tables
	 * @param {boolean} [options.optimizeCoding=true] - alternative spelling of optimiseCoding
	 * @param {boolean} [options.mozjpeg=false] - use mozjpeg defaults, equivalent to `{ trellisQuantisation: true, overshootDeringing: true, optimiseScans: true, quantisationTable: 3 }`
	 * @param {boolean} [options.trellisQuantisation=false] - apply trellis quantisation
	 * @param {boolean} [options.overshootDeringing=false] - apply overshoot deringing
	 * @param {boolean} [options.optimiseScans=false] - optimise progressive scans, forces progressive
	 * @param {boolean} [options.optimizeScans=false] - alternative spelling of optimiseScans
	 * @param {number} [options.quantisationTable=0] - quantization table to use, integer 0-8
	 * @param {number} [options.quantizationTable=0] - alternative spelling of quantisationTable
	 * @param {boolean} [options.force=true] - force JPEG output, otherwise attempt to use input format
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function jpeg (options) {
	  if (is.object(options)) {
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        this.options.jpegQuality = options.quality;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    }
	    if (is.defined(options.progressive)) {
	      this._setBooleanOption('jpegProgressive', options.progressive);
	    }
	    if (is.defined(options.chromaSubsampling)) {
	      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
	        this.options.jpegChromaSubsampling = options.chromaSubsampling;
	      } else {
	        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
	      }
	    }
	    const optimiseCoding = is.bool(options.optimizeCoding) ? options.optimizeCoding : options.optimiseCoding;
	    if (is.defined(optimiseCoding)) {
	      this._setBooleanOption('jpegOptimiseCoding', optimiseCoding);
	    }
	    if (is.defined(options.mozjpeg)) {
	      if (is.bool(options.mozjpeg)) {
	        if (options.mozjpeg) {
	          this.options.jpegTrellisQuantisation = true;
	          this.options.jpegOvershootDeringing = true;
	          this.options.jpegOptimiseScans = true;
	          this.options.jpegProgressive = true;
	          this.options.jpegQuantisationTable = 3;
	        }
	      } else {
	        throw is.invalidParameterError('mozjpeg', 'boolean', options.mozjpeg);
	      }
	    }
	    const trellisQuantisation = is.bool(options.trellisQuantization) ? options.trellisQuantization : options.trellisQuantisation;
	    if (is.defined(trellisQuantisation)) {
	      this._setBooleanOption('jpegTrellisQuantisation', trellisQuantisation);
	    }
	    if (is.defined(options.overshootDeringing)) {
	      this._setBooleanOption('jpegOvershootDeringing', options.overshootDeringing);
	    }
	    const optimiseScans = is.bool(options.optimizeScans) ? options.optimizeScans : options.optimiseScans;
	    if (is.defined(optimiseScans)) {
	      this._setBooleanOption('jpegOptimiseScans', optimiseScans);
	      if (optimiseScans) {
	        this.options.jpegProgressive = true;
	      }
	    }
	    const quantisationTable = is.number(options.quantizationTable) ? options.quantizationTable : options.quantisationTable;
	    if (is.defined(quantisationTable)) {
	      if (is.integer(quantisationTable) && is.inRange(quantisationTable, 0, 8)) {
	        this.options.jpegQuantisationTable = quantisationTable;
	      } else {
	        throw is.invalidParameterError('quantisationTable', 'integer between 0 and 8', quantisationTable);
	      }
	    }
	  }
	  return this._updateFormatOut('jpeg', options);
	}

	/**
	 * Use these PNG options for output image.
	 *
	 * By default, PNG output is full colour at 8 bits per pixel.
	 *
	 * Indexed PNG input at 1, 2 or 4 bits per pixel is converted to 8 bits per pixel.
	 * Set `palette` to `true` for slower, indexed PNG output.
	 *
	 * For 16 bits per pixel output, convert to `rgb16` via
	 * {@link /api-colour/#tocolourspace toColourspace}.
	 *
	 * @example
	 * // Convert any input to full colour PNG output
	 * const data = await sharp(input)
	 *   .png()
	 *   .toBuffer();
	 *
	 * @example
	 * // Convert any input to indexed PNG output (slower)
	 * const data = await sharp(input)
	 *   .png({ palette: true })
	 *   .toBuffer();
	 *
	 * @example
	 * // Output 16 bits per pixel RGB(A)
	 * const data = await sharp(input)
	 *  .toColourspace('rgb16')
	 *  .png()
	 *  .toBuffer();
	 *
	 * @param {Object} [options]
	 * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
	 * @param {number} [options.compressionLevel=6] - zlib compression level, 0 (fastest, largest) to 9 (slowest, smallest)
	 * @param {boolean} [options.adaptiveFiltering=false] - use adaptive row filtering
	 * @param {boolean} [options.palette=false] - quantise to a palette-based image with alpha transparency support
	 * @param {number} [options.quality=100] - use the lowest number of colours needed to achieve given quality, sets `palette` to `true`
	 * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest), sets `palette` to `true`
	 * @param {number} [options.colours=256] - maximum number of palette entries, sets `palette` to `true`
	 * @param {number} [options.colors=256] - alternative spelling of `options.colours`, sets `palette` to `true`
	 * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, sets `palette` to `true`
	 * @param {boolean} [options.force=true] - force PNG output, otherwise attempt to use input format
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function png (options) {
	  if (is.object(options)) {
	    if (is.defined(options.progressive)) {
	      this._setBooleanOption('pngProgressive', options.progressive);
	    }
	    if (is.defined(options.compressionLevel)) {
	      if (is.integer(options.compressionLevel) && is.inRange(options.compressionLevel, 0, 9)) {
	        this.options.pngCompressionLevel = options.compressionLevel;
	      } else {
	        throw is.invalidParameterError('compressionLevel', 'integer between 0 and 9', options.compressionLevel);
	      }
	    }
	    if (is.defined(options.adaptiveFiltering)) {
	      this._setBooleanOption('pngAdaptiveFiltering', options.adaptiveFiltering);
	    }
	    const colours = options.colours || options.colors;
	    if (is.defined(colours)) {
	      if (is.integer(colours) && is.inRange(colours, 2, 256)) {
	        this.options.pngBitdepth = bitdepthFromColourCount(colours);
	      } else {
	        throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
	      }
	    }
	    if (is.defined(options.palette)) {
	      this._setBooleanOption('pngPalette', options.palette);
	    } else if ([options.quality, options.effort, options.colours, options.colors, options.dither].some(is.defined)) {
	      this._setBooleanOption('pngPalette', true);
	    }
	    if (this.options.pngPalette) {
	      if (is.defined(options.quality)) {
	        if (is.integer(options.quality) && is.inRange(options.quality, 0, 100)) {
	          this.options.pngQuality = options.quality;
	        } else {
	          throw is.invalidParameterError('quality', 'integer between 0 and 100', options.quality);
	        }
	      }
	      if (is.defined(options.effort)) {
	        if (is.integer(options.effort) && is.inRange(options.effort, 1, 10)) {
	          this.options.pngEffort = options.effort;
	        } else {
	          throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
	        }
	      }
	      if (is.defined(options.dither)) {
	        if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
	          this.options.pngDither = options.dither;
	        } else {
	          throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
	        }
	      }
	    }
	  }
	  return this._updateFormatOut('png', options);
	}

	/**
	 * Use these WebP options for output image.
	 *
	 * @example
	 * // Convert any input to lossless WebP output
	 * const data = await sharp(input)
	 *   .webp({ lossless: true })
	 *   .toBuffer();
	 *
	 * @example
	 * // Optimise the file size of an animated WebP
	 * const outputWebp = await sharp(inputWebp, { animated: true })
	 *   .webp({ effort: 6 })
	 *   .toBuffer();
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.quality=80] - quality, integer 1-100
	 * @param {number} [options.alphaQuality=100] - quality of alpha layer, integer 0-100
	 * @param {boolean} [options.lossless=false] - use lossless compression mode
	 * @param {boolean} [options.nearLossless=false] - use near_lossless compression mode
	 * @param {boolean} [options.smartSubsample=false] - use high quality chroma subsampling
	 * @param {boolean} [options.smartDeblock=false] - auto-adjust the deblocking filter, can improve low contrast edges (slow)
	 * @param {string} [options.preset='default'] - named preset for preprocessing/filtering, one of: default, photo, picture, drawing, icon, text
	 * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 6 (slowest)
	 * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
	 * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
	 * @param {boolean} [options.minSize=false] - prevent use of animation key frames to minimise file size (slow)
	 * @param {boolean} [options.mixed=false] - allow mixture of lossy and lossless animation frames (slow)
	 * @param {boolean} [options.force=true] - force WebP output, otherwise attempt to use input format
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function webp (options) {
	  if (is.object(options)) {
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        this.options.webpQuality = options.quality;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    }
	    if (is.defined(options.alphaQuality)) {
	      if (is.integer(options.alphaQuality) && is.inRange(options.alphaQuality, 0, 100)) {
	        this.options.webpAlphaQuality = options.alphaQuality;
	      } else {
	        throw is.invalidParameterError('alphaQuality', 'integer between 0 and 100', options.alphaQuality);
	      }
	    }
	    if (is.defined(options.lossless)) {
	      this._setBooleanOption('webpLossless', options.lossless);
	    }
	    if (is.defined(options.nearLossless)) {
	      this._setBooleanOption('webpNearLossless', options.nearLossless);
	    }
	    if (is.defined(options.smartSubsample)) {
	      this._setBooleanOption('webpSmartSubsample', options.smartSubsample);
	    }
	    if (is.defined(options.smartDeblock)) {
	      this._setBooleanOption('webpSmartDeblock', options.smartDeblock);
	    }
	    if (is.defined(options.preset)) {
	      if (is.string(options.preset) && is.inArray(options.preset, ['default', 'photo', 'picture', 'drawing', 'icon', 'text'])) {
	        this.options.webpPreset = options.preset;
	      } else {
	        throw is.invalidParameterError('preset', 'one of: default, photo, picture, drawing, icon, text', options.preset);
	      }
	    }
	    if (is.defined(options.effort)) {
	      if (is.integer(options.effort) && is.inRange(options.effort, 0, 6)) {
	        this.options.webpEffort = options.effort;
	      } else {
	        throw is.invalidParameterError('effort', 'integer between 0 and 6', options.effort);
	      }
	    }
	    if (is.defined(options.minSize)) {
	      this._setBooleanOption('webpMinSize', options.minSize);
	    }
	    if (is.defined(options.mixed)) {
	      this._setBooleanOption('webpMixed', options.mixed);
	    }
	  }
	  trySetAnimationOptions(options, this.options);
	  return this._updateFormatOut('webp', options);
	}

	/**
	 * Use these GIF options for the output image.
	 *
	 * The first entry in the palette is reserved for transparency.
	 *
	 * The palette of the input image will be re-used if possible.
	 *
	 * @since 0.30.0
	 *
	 * @example
	 * // Convert PNG to GIF
	 * await sharp(pngBuffer)
	 *   .gif()
	 *   .toBuffer();
	 *
	 * @example
	 * // Convert animated WebP to animated GIF
	 * await sharp('animated.webp', { animated: true })
	 *   .toFile('animated.gif');
	 *
	 * @example
	 * // Create a 128x128, cropped, non-dithered, animated thumbnail of an animated GIF
	 * const out = await sharp('in.gif', { animated: true })
	 *   .resize({ width: 128, height: 128 })
	 *   .gif({ dither: 0 })
	 *   .toBuffer();
	 *
	 * @example
	 * // Lossy file size reduction of animated GIF
	 * await sharp('in.gif', { animated: true })
	 *   .gif({ interFrameMaxError: 8 })
	 *   .toFile('optim.gif');
	 *
	 * @param {Object} [options] - output options
	 * @param {boolean} [options.reuse=true] - re-use existing palette, otherwise generate new (slow)
	 * @param {boolean} [options.progressive=false] - use progressive (interlace) scan
	 * @param {number} [options.colours=256] - maximum number of palette entries, including transparency, between 2 and 256
	 * @param {number} [options.colors=256] - alternative spelling of `options.colours`
	 * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 10 (slowest)
	 * @param {number} [options.dither=1.0] - level of Floyd-Steinberg error diffusion, between 0 (least) and 1 (most)
	 * @param {number} [options.interFrameMaxError=0] - maximum inter-frame error for transparency, between 0 (lossless) and 32
	 * @param {number} [options.interPaletteMaxError=3] - maximum inter-palette error for palette reuse, between 0 and 256
	 * @param {boolean} [options.keepDuplicateFrames=false] - keep duplicate frames in the output instead of combining them
	 * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
	 * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
	 * @param {boolean} [options.force=true] - force GIF output, otherwise attempt to use input format
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function gif (options) {
	  if (is.object(options)) {
	    if (is.defined(options.reuse)) {
	      this._setBooleanOption('gifReuse', options.reuse);
	    }
	    if (is.defined(options.progressive)) {
	      this._setBooleanOption('gifProgressive', options.progressive);
	    }
	    const colours = options.colours || options.colors;
	    if (is.defined(colours)) {
	      if (is.integer(colours) && is.inRange(colours, 2, 256)) {
	        this.options.gifBitdepth = bitdepthFromColourCount(colours);
	      } else {
	        throw is.invalidParameterError('colours', 'integer between 2 and 256', colours);
	      }
	    }
	    if (is.defined(options.effort)) {
	      if (is.number(options.effort) && is.inRange(options.effort, 1, 10)) {
	        this.options.gifEffort = options.effort;
	      } else {
	        throw is.invalidParameterError('effort', 'integer between 1 and 10', options.effort);
	      }
	    }
	    if (is.defined(options.dither)) {
	      if (is.number(options.dither) && is.inRange(options.dither, 0, 1)) {
	        this.options.gifDither = options.dither;
	      } else {
	        throw is.invalidParameterError('dither', 'number between 0.0 and 1.0', options.dither);
	      }
	    }
	    if (is.defined(options.interFrameMaxError)) {
	      if (is.number(options.interFrameMaxError) && is.inRange(options.interFrameMaxError, 0, 32)) {
	        this.options.gifInterFrameMaxError = options.interFrameMaxError;
	      } else {
	        throw is.invalidParameterError('interFrameMaxError', 'number between 0.0 and 32.0', options.interFrameMaxError);
	      }
	    }
	    if (is.defined(options.interPaletteMaxError)) {
	      if (is.number(options.interPaletteMaxError) && is.inRange(options.interPaletteMaxError, 0, 256)) {
	        this.options.gifInterPaletteMaxError = options.interPaletteMaxError;
	      } else {
	        throw is.invalidParameterError('interPaletteMaxError', 'number between 0.0 and 256.0', options.interPaletteMaxError);
	      }
	    }
	    if (is.defined(options.keepDuplicateFrames)) {
	      if (is.bool(options.keepDuplicateFrames)) {
	        this._setBooleanOption('gifKeepDuplicateFrames', options.keepDuplicateFrames);
	      } else {
	        throw is.invalidParameterError('keepDuplicateFrames', 'boolean', options.keepDuplicateFrames);
	      }
	    }
	  }
	  trySetAnimationOptions(options, this.options);
	  return this._updateFormatOut('gif', options);
	}

	/**
	 * Use these JP2 options for output image.
	 *
	 * Requires libvips compiled with support for OpenJPEG.
	 * The prebuilt binaries do not include this - see
	 * {@link /install#custom-libvips installing a custom libvips}.
	 *
	 * @example
	 * // Convert any input to lossless JP2 output
	 * const data = await sharp(input)
	 *   .jp2({ lossless: true })
	 *   .toBuffer();
	 *
	 * @example
	 * // Convert any input to very high quality JP2 output
	 * const data = await sharp(input)
	 *   .jp2({
	 *     quality: 100,
	 *     chromaSubsampling: '4:4:4'
	 *   })
	 *   .toBuffer();
	 *
	 * @since 0.29.1
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.quality=80] - quality, integer 1-100
	 * @param {boolean} [options.lossless=false] - use lossless compression mode
	 * @param {number} [options.tileWidth=512] - horizontal tile size
	 * @param {number} [options.tileHeight=512] - vertical tile size
	 * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function jp2 (options) {
	  /* node:coverage ignore next 41 */
	  if (!this.constructor.format.jp2k.output.buffer) {
	    throw errJp2Save();
	  }
	  if (is.object(options)) {
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        this.options.jp2Quality = options.quality;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    }
	    if (is.defined(options.lossless)) {
	      if (is.bool(options.lossless)) {
	        this.options.jp2Lossless = options.lossless;
	      } else {
	        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
	      }
	    }
	    if (is.defined(options.tileWidth)) {
	      if (is.integer(options.tileWidth) && is.inRange(options.tileWidth, 1, 32768)) {
	        this.options.jp2TileWidth = options.tileWidth;
	      } else {
	        throw is.invalidParameterError('tileWidth', 'integer between 1 and 32768', options.tileWidth);
	      }
	    }
	    if (is.defined(options.tileHeight)) {
	      if (is.integer(options.tileHeight) && is.inRange(options.tileHeight, 1, 32768)) {
	        this.options.jp2TileHeight = options.tileHeight;
	      } else {
	        throw is.invalidParameterError('tileHeight', 'integer between 1 and 32768', options.tileHeight);
	      }
	    }
	    if (is.defined(options.chromaSubsampling)) {
	      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
	        this.options.jp2ChromaSubsampling = options.chromaSubsampling;
	      } else {
	        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
	      }
	    }
	  }
	  return this._updateFormatOut('jp2', options);
	}

	/**
	 * Set animation options if available.
	 * @private
	 *
	 * @param {Object} [source] - output options
	 * @param {number} [source.loop=0] - number of animation iterations, use 0 for infinite animation
	 * @param {number[]} [source.delay] - list of delays between animation frames (in milliseconds)
	 * @param {Object} [target] - target object for valid options
	 * @throws {Error} Invalid options
	 */
	function trySetAnimationOptions (source, target) {
	  if (is.object(source) && is.defined(source.loop)) {
	    if (is.integer(source.loop) && is.inRange(source.loop, 0, 65535)) {
	      target.loop = source.loop;
	    } else {
	      throw is.invalidParameterError('loop', 'integer between 0 and 65535', source.loop);
	    }
	  }
	  if (is.object(source) && is.defined(source.delay)) {
	    // We allow singular values as well
	    if (is.integer(source.delay) && is.inRange(source.delay, 0, 65535)) {
	      target.delay = [source.delay];
	    } else if (
	      Array.isArray(source.delay) &&
	      source.delay.every(is.integer) &&
	      source.delay.every(v => is.inRange(v, 0, 65535))) {
	      target.delay = source.delay;
	    } else {
	      throw is.invalidParameterError('delay', 'integer or an array of integers between 0 and 65535', source.delay);
	    }
	  }
	}

	/**
	 * Use these TIFF options for output image.
	 *
	 * The `density` can be set in pixels/inch via {@link #withmetadata withMetadata}
	 * instead of providing `xres` and `yres` in pixels/mm.
	 *
	 * @example
	 * // Convert SVG input to LZW-compressed, 1 bit per pixel TIFF output
	 * sharp('input.svg')
	 *   .tiff({
	 *     compression: 'lzw',
	 *     bitdepth: 1
	 *   })
	 *   .toFile('1-bpp-output.tiff')
	 *   .then(info => { ... });
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.quality=80] - quality, integer 1-100
	 * @param {boolean} [options.force=true] - force TIFF output, otherwise attempt to use input format
	 * @param {string} [options.compression='jpeg'] - compression options: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k
	 * @param {boolean} [options.bigtiff=false] - use BigTIFF variant (has no effect when compression is none)
	 * @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 {string} [options.resolutionUnit='inch'] - resolution unit options: inch, cm
	 * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
	 * @param {boolean} [options.miniswhite=false] - write 1-bit images as miniswhite
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function tiff (options) {
	  if (is.object(options)) {
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        this.options.tiffQuality = options.quality;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    }
	    if (is.defined(options.bitdepth)) {
	      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [1, 2, 4, 8])) {
	        this.options.tiffBitdepth = options.bitdepth;
	      } else {
	        throw is.invalidParameterError('bitdepth', '1, 2, 4 or 8', options.bitdepth);
	      }
	    }
	    // tiling
	    if (is.defined(options.tile)) {
	      this._setBooleanOption('tiffTile', options.tile);
	    }
	    if (is.defined(options.tileWidth)) {
	      if (is.integer(options.tileWidth) && options.tileWidth > 0) {
	        this.options.tiffTileWidth = options.tileWidth;
	      } else {
	        throw is.invalidParameterError('tileWidth', 'integer greater than zero', options.tileWidth);
	      }
	    }
	    if (is.defined(options.tileHeight)) {
	      if (is.integer(options.tileHeight) && options.tileHeight > 0) {
	        this.options.tiffTileHeight = options.tileHeight;
	      } else {
	        throw is.invalidParameterError('tileHeight', 'integer greater than zero', options.tileHeight);
	      }
	    }
	    // miniswhite
	    if (is.defined(options.miniswhite)) {
	      this._setBooleanOption('tiffMiniswhite', options.miniswhite);
	    }
	    // pyramid
	    if (is.defined(options.pyramid)) {
	      this._setBooleanOption('tiffPyramid', options.pyramid);
	    }
	    // resolution
	    if (is.defined(options.xres)) {
	      if (is.number(options.xres) && options.xres > 0) {
	        this.options.tiffXres = options.xres;
	      } else {
	        throw is.invalidParameterError('xres', 'number greater than zero', options.xres);
	      }
	    }
	    if (is.defined(options.yres)) {
	      if (is.number(options.yres) && options.yres > 0) {
	        this.options.tiffYres = options.yres;
	      } else {
	        throw is.invalidParameterError('yres', 'number greater than zero', options.yres);
	      }
	    }
	    // compression
	    if (is.defined(options.compression)) {
	      if (is.string(options.compression) && is.inArray(options.compression, ['none', 'jpeg', 'deflate', 'packbits', 'ccittfax4', 'lzw', 'webp', 'zstd', 'jp2k'])) {
	        this.options.tiffCompression = options.compression;
	      } else {
	        throw is.invalidParameterError('compression', 'one of: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k', options.compression);
	      }
	    }
	    // bigtiff
	    if (is.defined(options.bigtiff)) {
	      this._setBooleanOption('tiffBigtiff', options.bigtiff);
	    }
	    // predictor
	    if (is.defined(options.predictor)) {
	      if (is.string(options.predictor) && is.inArray(options.predictor, ['none', 'horizontal', 'float'])) {
	        this.options.tiffPredictor = options.predictor;
	      } else {
	        throw is.invalidParameterError('predictor', 'one of: none, horizontal, float', options.predictor);
	      }
	    }
	    // resolutionUnit
	    if (is.defined(options.resolutionUnit)) {
	      if (is.string(options.resolutionUnit) && is.inArray(options.resolutionUnit, ['inch', 'cm'])) {
	        this.options.tiffResolutionUnit = options.resolutionUnit;
	      } else {
	        throw is.invalidParameterError('resolutionUnit', 'one of: inch, cm', options.resolutionUnit);
	      }
	    }
	  }
	  return this._updateFormatOut('tiff', options);
	}

	/**
	 * Use these AVIF options for output image.
	 *
	 * AVIF image sequences are not supported.
	 * Prebuilt binaries support a bitdepth of 8 only.
	 *
	 * This feature is experimental on the Windows ARM64 platform
	 * and requires a CPU with ARM64v8.4 or later.
	 *
	 * @example
	 * const data = await sharp(input)
	 *   .avif({ effort: 2 })
	 *   .toBuffer();
	 *
	 * @example
	 * const data = await sharp(input)
	 *   .avif({ lossless: true })
	 *   .toBuffer();
	 *
	 * @since 0.27.0
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.quality=50] - quality, integer 1-100
	 * @param {boolean} [options.lossless=false] - use lossless compression
	 * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
	 * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
	 * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function avif (options) {
	  return this.heif({ ...options, compression: 'av1' });
	}

	/**
	 * Use these HEIF options for output image.
	 *
	 * Support for patent-encumbered HEIC images using `hevc` compression requires the use of a
	 * globally-installed libvips compiled with support for libheif, libde265 and x265.
	 *
	 * @example
	 * const data = await sharp(input)
	 *   .heif({ compression: 'hevc' })
	 *   .toBuffer();
	 *
	 * @since 0.23.0
	 *
	 * @param {Object} options - output options
	 * @param {string} options.compression - compression format: av1, hevc
	 * @param {number} [options.quality=50] - quality, integer 1-100
	 * @param {boolean} [options.lossless=false] - use lossless compression
	 * @param {number} [options.effort=4] - CPU effort, between 0 (fastest) and 9 (slowest)
	 * @param {string} [options.chromaSubsampling='4:4:4'] - set to '4:2:0' to use chroma subsampling
	 * @param {number} [options.bitdepth=8] - set bitdepth to 8, 10 or 12 bit
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function heif (options) {
	  if (is.object(options)) {
	    if (is.string(options.compression) && is.inArray(options.compression, ['av1', 'hevc'])) {
	      this.options.heifCompression = options.compression;
	    } else {
	      throw is.invalidParameterError('compression', 'one of: av1, hevc', options.compression);
	    }
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        this.options.heifQuality = options.quality;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    }
	    if (is.defined(options.lossless)) {
	      if (is.bool(options.lossless)) {
	        this.options.heifLossless = options.lossless;
	      } else {
	        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
	      }
	    }
	    if (is.defined(options.effort)) {
	      if (is.integer(options.effort) && is.inRange(options.effort, 0, 9)) {
	        this.options.heifEffort = options.effort;
	      } else {
	        throw is.invalidParameterError('effort', 'integer between 0 and 9', options.effort);
	      }
	    }
	    if (is.defined(options.chromaSubsampling)) {
	      if (is.string(options.chromaSubsampling) && is.inArray(options.chromaSubsampling, ['4:2:0', '4:4:4'])) {
	        this.options.heifChromaSubsampling = options.chromaSubsampling;
	      } else {
	        throw is.invalidParameterError('chromaSubsampling', 'one of: 4:2:0, 4:4:4', options.chromaSubsampling);
	      }
	    }
	    if (is.defined(options.bitdepth)) {
	      if (is.integer(options.bitdepth) && is.inArray(options.bitdepth, [8, 10, 12])) {
	        if (options.bitdepth !== 8 && this.constructor.versions.heif) {
	          throw is.invalidParameterError('bitdepth when using prebuilt binaries', 8, options.bitdepth);
	        }
	        this.options.heifBitdepth = options.bitdepth;
	      } else {
	        throw is.invalidParameterError('bitdepth', '8, 10 or 12', options.bitdepth);
	      }
	    }
	  } else {
	    throw is.invalidParameterError('options', 'Object', options);
	  }
	  return this._updateFormatOut('heif', options);
	}

	/**
	 * Use these JPEG-XL (JXL) options for output image.
	 *
	 * This feature is experimental, please do not use in production systems.
	 *
	 * Requires libvips compiled with support for libjxl.
	 * The prebuilt binaries do not include this - see
	 * {@link /install/#custom-libvips installing a custom libvips}.
	 *
	 * @since 0.31.3
	 *
	 * @param {Object} [options] - output options
	 * @param {number} [options.distance=1.0] - maximum encoding error, between 0 (highest quality) and 15 (lowest quality)
	 * @param {number} [options.quality] - calculate `distance` based on JPEG-like quality, between 1 and 100, overrides distance if specified
	 * @param {number} [options.decodingTier=0] - target decode speed tier, between 0 (highest quality) and 4 (lowest quality)
	 * @param {boolean} [options.lossless=false] - use lossless compression
	 * @param {number} [options.effort=7] - CPU effort, between 1 (fastest) and 9 (slowest)
	 * @param {number} [options.loop=0] - number of animation iterations, use 0 for infinite animation
	 * @param {number|number[]} [options.delay] - delay(s) between animation frames (in milliseconds)
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function jxl (options) {
	  if (is.object(options)) {
	    if (is.defined(options.quality)) {
	      if (is.integer(options.quality) && is.inRange(options.quality, 1, 100)) {
	        // https://github.com/libjxl/libjxl/blob/0aeea7f180bafd6893c1db8072dcb67d2aa5b03d/tools/cjxl_main.cc#L640-L644
	        this.options.jxlDistance = options.quality >= 30
	          ? 0.1 + (100 - options.quality) * 0.09
	          : 53 / 3000 * options.quality * options.quality - 23 / 20 * options.quality + 25;
	      } else {
	        throw is.invalidParameterError('quality', 'integer between 1 and 100', options.quality);
	      }
	    } else if (is.defined(options.distance)) {
	      if (is.number(options.distance) && is.inRange(options.distance, 0, 15)) {
	        this.options.jxlDistance = options.distance;
	      } else {
	        throw is.invalidParameterError('distance', 'number between 0.0 and 15.0', options.distance);
	      }
	    }
	    if (is.defined(options.decodingTier)) {
	      if (is.integer(options.decodingTier) && is.inRange(options.decodingTier, 0, 4)) {
	        this.options.jxlDecodingTier = options.decodingTier;
	      } else {
	        throw is.invalidParameterError('decodingTier', 'integer between 0 and 4', options.decodingTier);
	      }
	    }
	    if (is.defined(options.lossless)) {
	      if (is.bool(options.lossless)) {
	        this.options.jxlLossless = options.lossless;
	      } else {
	        throw is.invalidParameterError('lossless', 'boolean', options.lossless);
	      }
	    }
	    if (is.defined(options.effort)) {
	      if (is.integer(options.effort) && is.inRange(options.effort, 1, 9)) {
	        this.options.jxlEffort = options.effort;
	      } else {
	        throw is.invalidParameterError('effort', 'integer between 1 and 9', options.effort);
	      }
	    }
	  }
	  trySetAnimationOptions(options, this.options);
	  return this._updateFormatOut('jxl', options);
	}

	/**
	 * Force output to be raw, uncompressed pixel data.
	 * Pixel ordering is left-to-right, top-to-bottom, without padding.
	 * Channel ordering will be RGB or RGBA for non-greyscale colourspaces.
	 *
	 * @example
	 * // Extract raw, unsigned 8-bit RGB pixel data from JPEG input
	 * const { data, info } = await sharp('input.jpg')
	 *   .raw()
	 *   .toBuffer({ resolveWithObject: true });
	 *
	 * @example
	 * // Extract alpha channel as raw, unsigned 16-bit pixel data from PNG input
	 * const data = await sharp('input.png')
	 *   .ensureAlpha()
	 *   .extractChannel(3)
	 *   .toColourspace('b-w')
	 *   .raw({ depth: 'ushort' })
	 *   .toBuffer();
	 *
	 * @param {Object} [options] - output options
	 * @param {string} [options.depth='uchar'] - bit depth, one of: char, uchar (default), short, ushort, int, uint, float, complex, double, dpcomplex
	 * @returns {Sharp}
	 * @throws {Error} Invalid options
	 */
	function raw (options) {
	  if (is.object(options)) {
	    if (is.defined(options.depth)) {
	      if (is.string(options.depth) && is.inArray(options.depth,
	        ['char', 'uchar', 'short', 'ushort', 'int', 'uint', 'float', 'complex', 'double', 'dpcomplex']
	      )) {
	        this.options.rawDepth = options.depth;
	      } else {
	        throw is.invalidParameterError('depth', 'one of: char, uchar, short, ushort, int, uint, float, complex, double, dpcomplex', options.depth);
	      }
	    }
	  }
	  return this._updateFormatOut('raw');
	}

	/**
	 * Use tile-based deep zoom (image pyramid) output.
	 *
	 * Set the format and options for tile images via the `toFormat`, `jpeg`, `png` or `webp` functions.
	 * Use a `.zip` or `.szi` file extension with `toFile` to write to a compressed archive file format.
	 *
	 * The container will be set to `zip` when the output is a Buffer or Stream, otherwise it will default to `fs`.
	 *
	 * @example
	 *  sharp('input.tiff')
	 *   .png()
	 *   .tile({
	 *     size: 512
	 *   })
	 *   .toFile('output.dz', function(err, info) {
	 *     // output.dzi is the Deep Zoom XML definition
	 *     // output_files contains 512x512 tiles grouped by zoom level
	 *   });
	 *
	 * @example
	 * const zipFileWithTiles = await sharp(input)
	 *   .tile({ basename: "tiles" })
	 *   .toBuffer();
	 *
	 * @example
	 * const iiififier = sharp().tile({ layout: "iiif" });
	 * readableStream
	 *   .pipe(iiififier)
	 *   .pipe(writeableStream);
	 *
	 * @param {Object} [options]
	 * @param {number} [options.size=256] tile size in pixels, a value between 1 and 8192.
	 * @param {number} [options.overlap=0] tile overlap in pixels, a value between 0 and 8192.
	 * @param {number} [options.angle=0] tile angle of rotation, must be a multiple of 90.
	 * @param {string|Object} [options.background={r: 255, g: 255, b: 255, alpha: 1}] - background colour, parsed by the [color](https://www.npmjs.org/package/color) module, defaults to white without transparency.
	 * @param {string} [options.depth] how deep to make the pyramid, possible values are `onepixel`, `onetile` or `one`, default based on layout.
	 * @param {number} [options.skipBlanks=-1] Threshold to skip tile generation. Range is 0-255 for 8-bit images, 0-65535 for 16-bit images. Default is 5 for `google` layout, -1 (no skip) otherwise.
	 * @param {string} [options.container='fs'] tile container, with value `fs` (filesystem) or `zip` (compressed file).
	 * @param {string} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `iiif3`, `zoomify` or `google`.
	 * @param {boolean} [options.centre=false] centre image in tile.
	 * @param {boolean} [options.center=false] alternative spelling of centre.
	 * @param {string} [options.id='https://example.com/iiif'] when `layout` is `iiif`/`iiif3`, sets the `@id`/`id` attribute of `info.json`
	 * @param {string} [options.basename] the name of the directory within the zip file when container is `zip`.
	 * @returns {Sharp}
	 * @throws {Error} Invalid parameters
	 */
	function tile (options) {
	  if (is.object(options)) {
	    // Size of square tiles, in pixels
	    if (is.defined(options.size)) {
	      if (is.integer(options.size) && is.inRange(options.size, 1, 8192)) {
	        this.options.tileSize = options.size;
	      } else {
	        throw is.invalidParameterError('size', 'integer between 1 and 8192', options.size);
	      }
	    }
	    // Overlap of tiles, in pixels
	    if (is.defined(options.overlap)) {
	      if (is.integer(options.overlap) && is.inRange(options.overlap, 0, 8192)) {
	        if (options.overlap > this.options.tileSize) {
	          throw is.invalidParameterError('overlap', `<= size (${this.options.tileSize})`, options.overlap);
	        }
	        this.options.tileOverlap = options.overlap;
	      } else {
	        throw is.invalidParameterError('overlap', 'integer between 0 and 8192', options.overlap);
	      }
	    }
	    // Container
	    if (is.defined(options.container)) {
	      if (is.string(options.container) && is.inArray(options.container, ['fs', 'zip'])) {
	        this.options.tileContainer = options.container;
	      } else {
	        throw is.invalidParameterError('container', 'one of: fs, zip', options.container);
	      }
	    }
	    // Layout
	    if (is.defined(options.layout)) {
	      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'iiif3', 'zoomify'])) {
	        this.options.tileLayout = options.layout;
	      } else {
	        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, iiif3, zoomify', options.layout);
	      }
	    }
	    // Angle of rotation,
	    if (is.defined(options.angle)) {
	      if (is.integer(options.angle) && !(options.angle % 90)) {
	        this.options.tileAngle = options.angle;
	      } else {
	        throw is.invalidParameterError('angle', 'positive/negative multiple of 90', options.angle);
	      }
	    }
	    // Background colour
	    this._setBackgroundColourOption('tileBackground', options.background);
	    // Depth of tiles
	    if (is.defined(options.depth)) {
	      if (is.string(options.depth) && is.inArray(options.depth, ['onepixel', 'onetile', 'one'])) {
	        this.options.tileDepth = options.depth;
	      } else {
	        throw is.invalidParameterError('depth', 'one of: onepixel, onetile, one', options.depth);
	      }
	    }
	    // Threshold to skip blank tiles
	    if (is.defined(options.skipBlanks)) {
	      if (is.integer(options.skipBlanks) && is.inRange(options.skipBlanks, -1, 65535)) {
	        this.options.tileSkipBlanks = options.skipBlanks;
	      } else {
	        throw is.invalidParameterError('skipBlanks', 'integer between -1 and 255/65535', options.skipBlanks);
	      }
	    } else if (is.defined(options.layout) && options.layout === 'google') {
	      this.options.tileSkipBlanks = 5;
	    }
	    // Center image in tile
	    const centre = is.bool(options.center) ? options.center : options.centre;
	    if (is.defined(centre)) {
	      this._setBooleanOption('tileCentre', centre);
	    }
	    // @id attribute for IIIF layout
	    if (is.defined(options.id)) {
	      if (is.string(options.id)) {
	        this.options.tileId = options.id;
	      } else {
	        throw is.invalidParameterError('id', 'string', options.id);
	      }
	    }
	    // Basename for zip container
	    if (is.defined(options.basename)) {
	      if (is.string(options.basename)) {
	        this.options.tileBasename = options.basename;
	      } else {
	        throw is.invalidParameterError('basename', 'string', options.basename);
	      }
	    }
	  }
	  // Format
	  if (is.inArray(this.options.formatOut, ['jpeg', 'png', 'webp'])) {
	    this.options.tileFormat = this.options.formatOut;
	  } else if (this.options.formatOut !== 'input') {
	    throw is.invalidParameterError('format', 'one of: jpeg, png, webp', this.options.formatOut);
	  }
	  return this._updateFormatOut('dz');
	}

	/**
	 * Set a timeout for processing, in seconds.
	 * Use a value of zero to continue processing indefinitely, the default behaviour.
	 *
	 * The clock starts when libvips opens an input image for processing.
	 * Time spent waiting for a libuv thread to become available is not included.
	 *
	 * @example
	 * // Ensure processing takes no longer than 3 seconds
	 * try {
	 *   const data = await sharp(input)
	 *     .blur(1000)
	 *     .timeout({ seconds: 3 })
	 *     .toBuffer();
	 * } catch (err) {
	 *   if (err.message.includes('timeout')) { ... }
	 * }
	 *
	 * @since 0.29.2
	 *
	 * @param {Object} options
	 * @param {number} options.seconds - Number of seconds after which processing will be stopped
	 * @returns {Sharp}
	 */
	function timeout (options) {
	  if (!is.plainObject(options)) {
	    throw is.invalidParameterError('options', 'object', options);
	  }
	  if (is.integer(options.seconds) && is.inRange(options.seconds, 0, 3600)) {
	    this.options.timeoutSeconds = options.seconds;
	  } else {
	    throw is.invalidParameterError('seconds', 'integer between 0 and 3600', options.seconds);
	  }
	  return this;
	}

	/**
	 * Update the output format unless options.force is false,
	 * in which case revert to input format.
	 * @private
	 * @param {string} formatOut
	 * @param {Object} [options]
	 * @param {boolean} [options.force=true] - force output format, otherwise attempt to use input format
	 * @returns {Sharp}
	 */
	function _updateFormatOut (formatOut, options) {
	  if (!(is.object(options) && options.force === false)) {
	    this.options.formatOut = formatOut;
	  }
	  return this;
	}

	/**
	 * Update a boolean attribute of the this.options Object.
	 * @private
	 * @param {string} key
	 * @param {boolean} val
	 * @throws {Error} Invalid key
	 */
	function _setBooleanOption (key, val) {
	  if (is.bool(val)) {
	    this.options[key] = val;
	  } else {
	    throw is.invalidParameterError(key, 'boolean', val);
	  }
	}

	/**
	 * Called by a WriteableStream to notify us it is ready for data.
	 * @private
	 */
	function _read () {
	  if (!this.options.streamOut) {
	    this.options.streamOut = true;
	    const stack = Error();
	    this._pipeline(undefined, stack);
	  }
	}

	/**
	 * Invoke the C++ image processing pipeline
	 * Supports callback, stream and promise variants
	 * @private
	 */
	function _pipeline (callback, stack) {
	  if (typeof callback === 'function') {
	    // output=file/buffer
	    if (this._isStreamInput()) {
	      // output=file/buffer, input=stream
	      this.on('finish', () => {
	        this._flattenBufferIn();
	        sharp.pipeline(this.options, (err, data, info) => {
	          if (err) {
	            callback(is.nativeError(err, stack));
	          } else {
	            callback(null, data, info);
	          }
	        });
	      });
	    } else {
	      // output=file/buffer, input=file/buffer
	      sharp.pipeline(this.options, (err, data, info) => {
	        if (err) {
	          callback(is.nativeError(err, stack));
	        } else {
	          callback(null, data, info);
	        }
	      });
	    }
	    return this;
	  } else if (this.options.streamOut) {
	    // output=stream
	    if (this._isStreamInput()) {
	      // output=stream, input=stream
	      this.once('finish', () => {
	        this._flattenBufferIn();
	        sharp.pipeline(this.options, (err, data, info) => {
	          if (err) {
	            this.emit('error', is.nativeError(err, stack));
	          } else {
	            this.emit('info', info);
	            this.push(data);
	          }
	          this.push(null);
	          this.on('end', () => this.emit('close'));
	        });
	      });
	      if (this.streamInFinished) {
	        this.emit('finish');
	      }
	    } else {
	      // output=stream, input=file/buffer
	      sharp.pipeline(this.options, (err, data, info) => {
	        if (err) {
	          this.emit('error', is.nativeError(err, stack));
	        } else {
	          this.emit('info', info);
	          this.push(data);
	        }
	        this.push(null);
	        this.on('end', () => this.emit('close'));
	      });
	    }
	    return this;
	  } else {
	    // output=promise
	    if (this._isStreamInput()) {
	      // output=promise, input=stream
	      return new Promise((resolve, reject) => {
	        this.once('finish', () => {
	          this._flattenBufferIn();
	          sharp.pipeline(this.options, (err, data, info) => {
	            if (err) {
	              reject(is.nativeError(err, stack));
	            } else {
	              if (this.options.resolveWithObject) {
	                resolve({ data, info });
	              } else {
	                resolve(data);
	              }
	            }
	          });
	        });
	      });
	    } else {
	      // output=promise, input=file/buffer
	      return new Promise((resolve, reject) => {
	        sharp.pipeline(this.options, (err, data, info) => {
	          if (err) {
	            reject(is.nativeError(err, stack));
	          } else {
	            if (this.options.resolveWithObject) {
	              resolve({ data, info });
	            } else {
	              resolve(data);
	            }
	          }
	        });
	      });
	    }
	  }
	}

	/**
	 * Decorate the Sharp prototype with output-related functions.
	 * @module Sharp
	 * @private
	 */
	output = (Sharp) => {
	  Object.assign(Sharp.prototype, {
	    // Public
	    toFile,
	    toBuffer,
	    keepExif,
	    withExif,
	    withExifMerge,
	    keepIccProfile,
	    withIccProfile,
	    keepXmp,
	    withXmp,
	    keepMetadata,
	    withMetadata,
	    toFormat,
	    jpeg,
	    jp2,
	    png,
	    webp,
	    tiff,
	    avif,
	    heif,
	    jxl,
	    gif,
	    raw,
	    tile,
	    timeout,
	    // Private
	    _updateFormatOut,
	    _setBooleanOption,
	    _read,
	    _pipeline
	  });
	};
	return output;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var utility;
var hasRequiredUtility;

function requireUtility () {
	if (hasRequiredUtility) return utility;
	hasRequiredUtility = 1;
	const events = require$$0$3;
	const detectLibc = requireDetectLibc();

	const is = requireIs();
	const { runtimePlatformArch } = requireLibvips();
	const sharp = requireSharp();

	const runtimePlatform = runtimePlatformArch();
	const libvipsVersion = sharp.libvipsVersion();

	/**
	 * An Object containing nested boolean values representing the available input and output formats/methods.
	 * @member
	 * @example
	 * console.log(sharp.format);
	 * @returns {Object}
	 */
	const format = sharp.format();
	format.heif.output.alias = ['avif', 'heic'];
	format.jpeg.output.alias = ['jpe', 'jpg'];
	format.tiff.output.alias = ['tif'];
	format.jp2k.output.alias = ['j2c', 'j2k', 'jp2', 'jpx'];

	/**
	 * An Object containing the available interpolators and their proper values
	 * @readonly
	 * @enum {string}
	 */
	const interpolators = {
	  /** [Nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation). Suitable for image enlargement only. */
	  nearest: 'nearest',
	  /** [Bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation). Faster than bicubic but with less smooth results. */
	  bilinear: 'bilinear',
	  /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
	  bicubic: 'bicubic',
	  /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
	  locallyBoundedBicubic: 'lbb',
	  /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
	  nohalo: 'nohalo',
	  /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
	  vertexSplitQuadraticBasisSpline: 'vsqbs'
	};

	/**
	 * An Object containing the version numbers of sharp, libvips
	 * and (when using prebuilt binaries) its dependencies.
	 *
	 * @member
	 * @example
	 * console.log(sharp.versions);
	 */
	let versions = {
	  vips: libvipsVersion.semver
	};
	/* node:coverage ignore next 15 */
	if (!libvipsVersion.isGlobal) {
	  if (!libvipsVersion.isWasm) {
	    try {
	      versions = commonjsRequire(`@img/sharp-${runtimePlatform}/versions`);
	    } catch (_) {
	      try {
	        versions = commonjsRequire(`@img/sharp-libvips-${runtimePlatform}/versions`);
	      } catch (_) {}
	    }
	  } else {
	    try {
	      versions = require('@img/sharp-wasm32/versions');
	    } catch (_) {}
	  }
	}
	versions.sharp = require$$6.version;

	/* node:coverage ignore next 5 */
	if (versions.heif && format.heif) {
	  // Prebuilt binaries provide AV1
	  format.heif.input.fileSuffix = ['.avif'];
	  format.heif.output.alias = ['avif'];
	}

	/**
	 * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
	 * Existing entries in the cache will be trimmed after any change in limits.
	 * This method always returns cache statistics,
	 * useful for determining how much working memory is required for a particular task.
	 *
	 * @example
	 * const stats = sharp.cache();
	 * @example
	 * sharp.cache( { items: 200 } );
	 * sharp.cache( { files: 0 } );
	 * sharp.cache(false);
	 *
	 * @param {Object|boolean} [options=true] - Object with the following attributes, or boolean where true uses default cache settings and false removes all caching
	 * @param {number} [options.memory=50] - is the maximum memory in MB to use for this cache
	 * @param {number} [options.files=20] - is the maximum number of files to hold open
	 * @param {number} [options.items=100] - is the maximum number of operations to cache
	 * @returns {Object}
	 */
	function cache (options) {
	  if (is.bool(options)) {
	    if (options) {
	      // Default cache settings of 50MB, 20 files, 100 items
	      return sharp.cache(50, 20, 100);
	    } else {
	      return sharp.cache(0, 0, 0);
	    }
	  } else if (is.object(options)) {
	    return sharp.cache(options.memory, options.files, options.items);
	  } else {
	    return sharp.cache();
	  }
	}
	cache(true);

	/**
	 * Gets or, when a concurrency is provided, sets
	 * the maximum number of threads _libvips_ should use to process _each image_.
	 * These are from a thread pool managed by glib,
	 * which helps avoid the overhead of creating new threads.
	 *
	 * This method always returns the current concurrency.
	 *
	 * The default value is the number of CPU cores,
	 * except when using glibc-based Linux without jemalloc,
	 * where the default is `1` to help reduce memory fragmentation.
	 *
	 * A value of `0` will reset this to the number of CPU cores.
	 *
	 * Some image format libraries spawn additional threads,
	 * e.g. libaom manages its own 4 threads when encoding AVIF images,
	 * and these are independent of the value set here.
	 *
	 * :::note
	 * Further {@link /performance/ control over performance} is available.
	 * :::
	 *
	 * @example
	 * const threads = sharp.concurrency(); // 4
	 * sharp.concurrency(2); // 2
	 * sharp.concurrency(0); // 4
	 *
	 * @param {number} [concurrency]
	 * @returns {number} concurrency
	 */
	function concurrency (concurrency) {
	  return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
	}
	/* node:coverage ignore next 7 */
	if (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) {
	  // Reduce default concurrency when musl thread over-subscription detected
	  sharp.concurrency(require$$7.availableParallelism());
	}

	/**
	 * An EventEmitter that emits a `change` event when a task is either:
	 * - queued, waiting for _libuv_ to provide a worker thread
	 * - complete
	 * @member
	 * @example
	 * sharp.queue.on('change', function(queueLength) {
	 *   console.log('Queue contains ' + queueLength + ' task(s)');
	 * });
	 */
	const queue = new events.EventEmitter();

	/**
	 * Provides access to internal task counters.
	 * - queue is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
	 * - process is the number of resize tasks currently being processed.
	 *
	 * @example
	 * const counters = sharp.counters(); // { queue: 2, process: 4 }
	 *
	 * @returns {Object}
	 */
	function counters () {
	  return sharp.counters();
	}

	/**
	 * Get and set use of SIMD vector unit instructions.
	 * Requires libvips to have been compiled with highway support.
	 *
	 * Improves the performance of `resize`, `blur` and `sharpen` operations
	 * by taking advantage of the SIMD vector unit of the CPU, e.g. Intel SSE and ARM NEON.
	 *
	 * @example
	 * const simd = sharp.simd();
	 * // simd is `true` if the runtime use of highway is currently enabled
	 * @example
	 * const simd = sharp.simd(false);
	 * // prevent libvips from using highway at runtime
	 *
	 * @param {boolean} [simd=true]
	 * @returns {boolean}
	 */
	function simd (simd) {
	  return sharp.simd(is.bool(simd) ? simd : null);
	}

	/**
	 * Block libvips operations at runtime.
	 *
	 * This is in addition to the `VIPS_BLOCK_UNTRUSTED` environment variable,
	 * which when set will block all "untrusted" operations.
	 *
	 * @since 0.32.4
	 *
	 * @example <caption>Block all TIFF input.</caption>
	 * sharp.block({
	 *   operation: ['VipsForeignLoadTiff']
	 * });
	 *
	 * @param {Object} options
	 * @param {Array<string>} options.operation - List of libvips low-level operation names to block.
	 */
	function block (options) {
	  if (is.object(options)) {
	    if (Array.isArray(options.operation) && options.operation.every(is.string)) {
	      sharp.block(options.operation, true);
	    } else {
	      throw is.invalidParameterError('operation', 'Array<string>', options.operation);
	    }
	  } else {
	    throw is.invalidParameterError('options', 'object', options);
	  }
	}

	/**
	 * Unblock libvips operations at runtime.
	 *
	 * This is useful for defining a list of allowed operations.
	 *
	 * @since 0.32.4
	 *
	 * @example <caption>Block all input except WebP from the filesystem.</caption>
	 * sharp.block({
	 *   operation: ['VipsForeignLoad']
	 * });
	 * sharp.unblock({
	 *   operation: ['VipsForeignLoadWebpFile']
	 * });
	 *
	 * @example <caption>Block all input except JPEG and PNG from a Buffer or Stream.</caption>
	 * sharp.block({
	 *   operation: ['VipsForeignLoad']
	 * });
	 * sharp.unblock({
	 *   operation: ['VipsForeignLoadJpegBuffer', 'VipsForeignLoadPngBuffer']
	 * });
	 *
	 * @param {Object} options
	 * @param {Array<string>} options.operation - List of libvips low-level operation names to unblock.
	 */
	function unblock (options) {
	  if (is.object(options)) {
	    if (Array.isArray(options.operation) && options.operation.every(is.string)) {
	      sharp.block(options.operation, false);
	    } else {
	      throw is.invalidParameterError('operation', 'Array<string>', options.operation);
	    }
	  } else {
	    throw is.invalidParameterError('options', 'object', options);
	  }
	}

	/**
	 * Decorate the Sharp class with utility-related functions.
	 * @module Sharp
	 * @private
	 */
	utility = (Sharp) => {
	  Sharp.cache = cache;
	  Sharp.concurrency = concurrency;
	  Sharp.counters = counters;
	  Sharp.simd = simd;
	  Sharp.format = format;
	  Sharp.interpolators = interpolators;
	  Sharp.versions = versions;
	  Sharp.queue = queue;
	  Sharp.block = block;
	  Sharp.unblock = unblock;
	};
	return utility;
}

/*!
  Copyright 2013 Lovell Fuller and others.
  SPDX-License-Identifier: Apache-2.0
*/

var lib;
var hasRequiredLib;

function requireLib () {
	if (hasRequiredLib) return lib;
	hasRequiredLib = 1;
	const Sharp = requireConstructor();
	requireInput()(Sharp);
	requireResize()(Sharp);
	requireComposite()(Sharp);
	requireOperation()(Sharp);
	requireColour()(Sharp);
	requireChannel()(Sharp);
	requireOutput()(Sharp);
	requireUtility()(Sharp);

	lib = Sharp;
	return lib;
}

var libExports = requireLib();
const index = /*@__PURE__*/getDefaultExportFromCjs(libExports);

const index$1 = /*#__PURE__*/_mergeNamespaces({
  __proto__: null,
  default: index
}, [libExports]);

export { index$1 as i };