@basemaps/lambda-tiler 6.15.0

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const detectLibc = require('detect-libc');
+
+const env = process.env;
+
+module.exports = function () {
+  const arch = env.npm_config_arch || process.arch;
+  const platform = env.npm_config_platform || process.platform;
+  /* istanbul ignore next */
+  const libc = (platform === 'linux' && detectLibc.isNonGlibcLinux) ? detectLibc.family : '';
+
+  const platformId = [`${platform}${libc}`];
+
+  if (arch === 'arm') {
+    const fallback = process.versions.electron ? '7' : '6';
+    platformId.push(`armv${env.npm_config_arm_version || process.config.variables.arm_version || fallback}`);
+  } else if (arch === 'arm64') {
+    platformId.push(`arm64v${env.npm_config_arm_version || '8'}`);
+  } else {
+    platformId.push(arch);
+  }
+
+  return platformId.join('-');
+};

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

@@ -0,0 +1,454 @@
+'use strict';
+
+const is = require('./is');
+
+/**
+ * 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
+};
+
+/**
+ * Strategies for automagic cover behaviour.
+ * @member
+ * @private
+ */
+const strategy = {
+  entropy: 16,
+  attention: 17
+};
+
+/**
+ * Reduction kernels.
+ * @member
+ * @private
+ */
+const kernel = {
+  nearest: 'nearest',
+  cubic: 'cubic',
+  mitchell: 'mitchell',
+  lanczos2: 'lanczos2',
+  lanczos3: 'lanczos3'
+};
+
+/**
+ * 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.useExifOrientation === true || options.rotationAngle !== 0;
+}
+
+/**
+ * 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, 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.
+ *
+ * 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 experimental strategy-based approach 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 interpolation kernels are:
+ * - `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
+ * - `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).
+ *
+ * @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
+ * const scaleByHalf = await sharp(input)
+ *   .metadata()
+ *   .then(({ width }) => sharp(input)
+ *     .resize(Math.round(width * 0.5))
+ *     .toBuffer()
+ *   );
+ *
+ * @param {number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+ * @param {number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+ * @param {Object} [options]
+ * @param {String} [options.width] - alternative means of specifying `width`. If both are present this take priority.
+ * @param {String} [options.height] - alternative means of specifying `height`. If both are present this take priority.
+ * @param {String} [options.fit='cover'] - how the image should be resized to fit both provided dimensions, one of `cover`, `contain`, `fill`, `inside` or `outside`.
+ * @param {String} [options.position='centre'] - 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 using a `fit` of `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.
+ * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option.
+ * @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 on some images.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function resize (width, height, options) {
+  if (is.defined(width)) {
+    if (is.object(width) && !is.defined(options)) {
+      options = width;
+    } else if (is.integer(width) && width > 0) {
+      this.options.width = width;
+    } else {
+      throw is.invalidParameterError('width', 'positive integer', width);
+    }
+  } 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);
+    }
+    // Shrink on load
+    if (is.defined(options.fastShrinkOnLoad)) {
+      this._setBooleanOption('fastShrinkOnLoad', options.fastShrinkOnLoad);
+    }
+  }
+  return this;
+}
+
+/**
+ * Extends/pads the edges of the image with the provided background colour.
+ * 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'
+ *   })
+ *   ...
+ *
+ * @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|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);
+  } 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` before and after for both.
+ *
+ * @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 = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
+  ['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 (suffix === 'Pre' && isRotationExpected(this.options)) {
+    this.options.rotateBeforePreExtract = true;
+  }
+  return this;
+}
+
+/**
+ * Trim "boring" pixels from all edges that contain values similar to the top-left pixel.
+ * Images consisting entirely of a single colour will calculate "boring" using the alpha channel, if any.
+ *
+ * The `info` response Object, obtained from callback of `.toFile()` or `.toBuffer()`,
+ * will contain `trimOffsetLeft` and `trimOffsetTop` properties.
+ *
+ * @param {number} [threshold=10] the allowed difference from the top-left pixel, a number greater than zero.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function trim (threshold) {
+  if (!is.defined(threshold)) {
+    this.options.trimThreshold = 10;
+  } else if (is.number(threshold) && threshold > 0) {
+    this.options.trimThreshold = threshold;
+  } else {
+    throw is.invalidParameterError('threshold', 'number greater than zero', threshold);
+  }
+  if (this.options.trimThreshold && isRotationExpected(this.options)) {
+    this.options.rotateBeforePreExtract = true;
+  }
+  return this;
+}
+
+/**
+ * Decorate the Sharp prototype with resize-related functions.
+ * @private
+ */
+module.exports = function (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;
+};

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

@@ -0,0 +1,179 @@
+'use strict';
+
+const events = require('events');
+const detectLibc = require('detect-libc');
+
+const is = require('./is');
+const sharp = require('../build/Release/sharp.node');
+
+/**
+ * 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();
+
+/**
+ * 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/jcupitt/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/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+
+/**
+ * An Object containing the version numbers of libvips and its dependencies.
+ * @member
+ * @example
+ * console.log(sharp.versions);
+ */
+let versions = {
+  vips: sharp.libvipsVersion()
+};
+try {
+  versions = require(`../vendor/${versions.vips}/versions.json`);
+} catch (err) {}
+
+/**
+ * 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 number of threads _libvips'_ should create to process each image.
+ *
+ * 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.
+ *
+ * The maximum number of images that can be processed in parallel
+ * is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+ *
+ * This method always returns the current concurrency.
+ *
+ * @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);
+}
+/* istanbul ignore next */
+if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+  // Reduce default concurrency to 1 when using glibc memory allocator
+  sharp.concurrency(1);
+}
+
+/**
+ * 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 liborc 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 liborc is currently enabled
+ * @example
+ * const simd = sharp.simd(false);
+ * // prevent libvips from using liborc at runtime
+ *
+ * @param {boolean} [simd=true]
+ * @returns {boolean}
+ */
+function simd (simd) {
+  return sharp.simd(is.bool(simd) ? simd : null);
+}
+simd(true);
+
+/**
+ * Decorate the Sharp class with utility-related functions.
+ * @private
+ */
+module.exports = function (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;
+};