@basemaps/lambda-tiler 6.19.0 → 6.22.0

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

@@ -1,167 +0,0 @@
-'use strict';
-
-const is = require('./is');
-
-/**
- * Boolean operations for bandbool.
- * @private
- */
-const bool = {
-  and: 'and',
-  or: 'or',
-  eor: 'eor'
-};
-
-/**
- * Remove alpha channel, if any. This is a no-op if the image does not have an alpha channel.
- *
- * See also {@link /api-operation#flatten|flatten}.
- *
- * @example
- * sharp('rgba.png')
- *   .removeAlpha()
- *   .toFile('rgb.png', function(err, info) {
- *     // rgb.png is a 3 channel image without an alpha channel
- *   });
- *
- * @returns {Sharp}
- */
-function removeAlpha () {
-  this.options.removeAlpha = true;
-  return this;
-}
-
-/**
- * Ensure the output image has an alpha transparency channel.
- * If missing, the added alpha channel will have the specified
- * transparency level, defaulting to fully-opaque (1).
- * This is a no-op if the image already has an alpha channel.
- *
- * @since 0.21.2
- *
- * @example
- * // rgba.png will be a 4 channel image with a fully-opaque alpha channel
- * await sharp('rgb.jpg')
- *   .ensureAlpha()
- *   .toFile('rgba.png')
- *
- * @example
- * // rgba is a 4 channel image with a fully-transparent alpha channel
- * const rgba = await sharp(rgb)
- *   .ensureAlpha(0)
- *   .toBuffer();
- *
- * @param {number} [alpha=1] - alpha transparency level (0=fully-transparent, 1=fully-opaque)
- * @returns {Sharp}
- * @throws {Error} Invalid alpha transparency level
- */
-function ensureAlpha (alpha) {
-  if (is.defined(alpha)) {
-    if (is.number(alpha) && is.inRange(alpha, 0, 1)) {
-      this.options.ensureAlpha = alpha;
-    } else {
-      throw is.invalidParameterError('alpha', 'number between 0 and 1', alpha);
-    }
-  } else {
-    this.options.ensureAlpha = 1;
-  }
-  return this;
-}
-
-/**
- * Extract a single channel from a multi-channel image.
- *
- * @example
- * sharp(input)
- *   .extractChannel('green')
- *   .toColourspace('b-w')
- *   .toFile('green.jpg', function(err, info) {
- *     // info.channels === 1
- *     // green.jpg is a greyscale image containing the green channel of the input
- *    });
- *
- * @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.
- * @private
- */
-module.exports = function (Sharp) {
-  Object.assign(Sharp.prototype, {
-    // Public instance functions
-    removeAlpha,
-    ensureAlpha,
-    extractChannel,
-    joinChannel,
-    bandbool
-  });
-  // Class attributes
-  Sharp.bool = bool;
-};

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

@@ -1,130 +0,0 @@
-'use strict';
-
-const color = require('color');
-const is = require('./is');
-
-/**
- * Colourspaces.
- * @private
- */
-const colourspace = {
-  multiband: 'multiband',
-  'b-w': 'b-w',
-  bw: 'b-w',
-  cmyk: 'cmyk',
-  srgb: 'srgb'
-};
-
-/**
- * Tint the image using the provided chroma while preserving the image luminance.
- * An alpha channel may be present and will be unchanged by the operation.
- *
- * @param {string|Object} rgb - parsed by the [color](https://www.npmjs.org/package/color) module to extract chroma values.
- * @returns {Sharp}
- * @throws {Error} Invalid parameter
- */
-function tint (rgb) {
-  const colour = color(rgb);
-  this.options.tintA = colour.a();
-  this.options.tintB = colour.b();
-  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) color channels.
- * This may be overridden by other sharp operations such as `toColourspace('b-w')`,
- * which will produce an output image containing one color channel.
- * An alpha channel may be present, and will be unchanged by the operation.
- * @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 output colourspace.
- * By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
- *
- * @example
- * // Output 16 bits per pixel RGB
- * await sharp(input)
- *  .toColourspace('rgb16')
- *  .toFile('16-bpp.png')
- *
- * @param {string} [colourspace] - output colourspace e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
- */
-function toColourspace (colourspace) {
-  if (!is.string(colourspace)) {
-    throw is.invalidParameterError('colourspace', 'string', colourspace);
-  }
-  this.options.colourspace = colourspace;
-  return this;
-}
-
-/**
- * Alternative spelling of `toColourspace`.
- * @param {string} [colorspace] - output colorspace.
- * @returns {Sharp}
- * @throws {Error} Invalid parameters
- */
-function toColorspace (colorspace) {
-  return this.toColourspace(colorspace);
-}
-
-/**
- * Update a colour attribute of the this.options Object.
- * @private
- * @param {string} key
- * @param {string|Object} value
- * @throws {Error} Invalid value
- */
-function _setBackgroundColourOption (key, value) {
-  if (is.defined(value)) {
-    if (is.object(value) || is.string(value)) {
-      const colour = color(value);
-      this.options[key] = [
-        colour.red(),
-        colour.green(),
-        colour.blue(),
-        Math.round(colour.alpha() * 255)
-      ];
-    } else {
-      throw is.invalidParameterError('background', 'object or string', value);
-    }
-  }
-}
-
-/**
- * Decorate the Sharp prototype with colour-related functions.
- * @private
- */
-module.exports = function (Sharp) {
-  Object.assign(Sharp.prototype, {
-    // Public
-    tint,
-    greyscale,
-    grayscale,
-    toColourspace,
-    toColorspace,
-    // Private
-    _setBackgroundColourOption
-  });
-  // Class attributes
-  Sharp.colourspace = colourspace;
-  Sharp.colorspace = colourspace;
-};

package/dist/node_modules/sharp/lib/composite.js

@@ -1,178 +0,0 @@
-'use strict';
-
-const is = require('./is');
-
-/**
- * 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`.
- *
- * 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://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsBlendMode
- * and https://www.cairographics.org/operators/
- *
- * @since 0.22.0
- *
- * @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 {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 premultipling 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[].failOnError=true] - @see {@link /api-constructor#parameters|constructor parameters}
- * @param {number|boolean} [images[].limitInputPixels=268402689] - @see {@link /api-constructor#parameters|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.
- * @private
- */
-module.exports = function (Sharp) {
-  Sharp.prototype.composite = composite;
-  Sharp.blend = blend;
-};