@basemaps/lambda-tiler 6.15.0

package/dist/node_modules/sharp/src/common.h

@@ -0,0 +1,308 @@
+// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 6)
+#error "libvips version 8.10.6+ is required - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
+#error "GCC version 4.6+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if (defined(__clang__) && defined(__has_feature))
+#if (!__has_feature(cxx_range_for))
+#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+#endif
+
+using vips::VImage;
+
+namespace sharp {
+
+  struct InputDescriptor {  // NOLINT(runtime/indentation_namespace)
+    std::string name;
+    std::string file;
+    char *buffer;
+    bool failOnError;
+    int limitInputPixels;
+    VipsAccess access;
+    size_t bufferLength;
+    bool isBuffer;
+    double density;
+    int rawChannels;
+    int rawWidth;
+    int rawHeight;
+    bool rawPremultiplied;
+    int pages;
+    int page;
+    int level;
+    int subifd;
+    int createChannels;
+    int createWidth;
+    int createHeight;
+    std::vector<double> createBackground;
+    std::string createNoiseType;
+    double createNoiseMean;
+    double createNoiseSigma;
+
+    InputDescriptor():
+      buffer(nullptr),
+      failOnError(TRUE),
+      limitInputPixels(0x3FFF * 0x3FFF),
+      access(VIPS_ACCESS_RANDOM),
+      bufferLength(0),
+      isBuffer(FALSE),
+      density(72.0),
+      rawChannels(0),
+      rawWidth(0),
+      rawHeight(0),
+      rawPremultiplied(false),
+      pages(1),
+      page(0),
+      level(0),
+      subifd(-1),
+      createChannels(0),
+      createWidth(0),
+      createHeight(0),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0) {}
+  };
+
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
+  double AttrAsDouble(Napi::Object obj, std::string attr);
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr);
+  bool AttrAsBool(Napi::Object obj, std::string attr);
+  std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr);
+  std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr);
+
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input);
+
+  enum class ImageType {
+    JPEG,
+    PNG,
+    WEBP,
+    TIFF,
+    GIF,
+    SVG,
+    HEIF,
+    PDF,
+    MAGICK,
+    OPENSLIDE,
+    PPM,
+    FITS,
+    EXR,
+    VIPS,
+    RAW,
+    UNKNOWN,
+    MISSING
+  };
+
+  // How many tasks are in the queue?
+  extern volatile int counterQueue;
+
+  // How many tasks are being processed?
+  extern volatile int counterProcess;
+
+  // Filename extension checkers
+  bool IsJpeg(std::string const &str);
+  bool IsPng(std::string const &str);
+  bool IsWebp(std::string const &str);
+  bool IsGif(std::string const &str);
+  bool IsTiff(std::string const &str);
+  bool IsHeic(std::string const &str);
+  bool IsHeif(std::string const &str);
+  bool IsAvif(std::string const &str);
+  bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
+
+  /*
+    Provide a string identifier for the given image type.
+  */
+  std::string ImageTypeId(ImageType const imageType);
+
+  /*
+    Determine image format of a buffer.
+  */
+  ImageType DetermineImageType(void *buffer, size_t const length);
+
+  /*
+    Determine image format of a file.
+  */
+  ImageType DetermineImageType(char const *file);
+
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType);
+
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor);
+
+  /*
+    Does this image have an embedded profile?
+  */
+  bool HasProfile(VImage image);
+
+  /*
+    Does this image have an alpha channel?
+    Uses colour space interpretation with number of channels to guess this.
+  */
+  bool HasAlpha(VImage image);
+
+  /*
+    Get EXIF Orientation of image, if any.
+  */
+  int ExifOrientation(VImage image);
+
+  /*
+    Set EXIF Orientation of image.
+  */
+  VImage SetExifOrientation(VImage image, int const orientation);
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  VImage RemoveExifOrientation(VImage image);
+
+  /*
+    Set animation properties if necessary.
+    Non-provided properties will be loaded from image.
+  */
+  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop);
+
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image);
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image);
+
+  /*
+    Set pixels/mm resolution based on a pixels/inch density.
+  */
+  VImage SetDensity(VImage image, const double density);
+
+  /*
+    Check the proposed format supports the current dimensions.
+  */
+  void AssertImageTypeDimensions(VImage image, ImageType const imageType);
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  extern std::function<void(void*, char*)> FreeCallback;
+
+  /*
+    Called with warnings from the glib-registered "VIPS" domain
+  */
+  void VipsWarningCallback(char const* log_domain, GLogLevelFlags log_level, char const* message, void* ignore);
+
+  /*
+    Pop the oldest warning message from the queue
+  */
+  std::string VipsWarningPop();
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity during an embed.
+  */
+  std::tuple<int, int> CalculateEmbedPosition(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr);
+
+  /*
+    Get interpretation type from string
+  */
+  VipsInterpretation GetInterpretation(std::string const typeStr);
+
+  /*
+    Convert RGBA value to another colourspace
+  */
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
+
+  /*
+    Apply the alpha channel to a given colour
+   */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour);
+
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image);
+
+  /*
+    Ensures alpha channel, if missing.
+  */
+  VImage EnsureAlpha(VImage image, double const value);
+
+}  // namespace sharp
+
+#endif  // SRC_COMMON_H_

package/dist/node_modules/sharp/src/libvips/cplusplus/VConnection.cpp

@@ -0,0 +1,178 @@
+/* Object part of the VSource and VTarget class
+ */
+
+/*
+
+    Copyright (C) 1991-2001 The National Gallery
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301  USA
+
+ */
+
+/*
+
+    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+#include <vips/intl.h>
+
+#include <vips/vips8>
+
+#include <vips/debug.h>
+
+/*
+#define VIPS_DEBUG
+#define VIPS_DEBUG_VERBOSE
+ */
+
+VIPS_NAMESPACE_START
+
+VSource 
+VSource::new_from_descriptor( int descriptor )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_descriptor( descriptor )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_file( const char *filename )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_file( filename )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_blob( VipsBlob *blob )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_blob( blob )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_memory( const void *data, 
+	size_t size )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_memory( data, size )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VSource 
+VSource::new_from_options( const char *options )
+{
+	VipsSource *input;
+
+	if( !(input = vips_source_new_from_options( options )) )
+		throw VError();
+
+	VSource out( input ); 
+
+	return( out ); 
+}
+
+VOption *
+VOption::set( const char *name, const VSource value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, VIPS_TYPE_SOURCE );
+	g_value_set_object( &pair->value, value.get_source() );
+	options.push_back( pair );
+
+	return( this );
+}
+
+VTarget 
+VTarget::new_to_descriptor( int descriptor )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_descriptor( descriptor )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_file( const char *filename )
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_file( filename )) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VTarget 
+VTarget::new_to_memory()
+{
+	VipsTarget *output;
+
+	if( !(output = vips_target_new_to_memory()) )
+		throw VError();
+
+	VTarget out( output ); 
+
+	return( out ); 
+}
+
+VOption *
+VOption::set( const char *name, const VTarget value )
+{
+	Pair *pair = new Pair( name );
+
+	pair->input = true;
+	g_value_init( &pair->value, VIPS_TYPE_TARGET );
+	g_value_set_object( &pair->value, value.get_target() );
+	options.push_back( pair );
+
+	return( this );
+}
+
+VIPS_NAMESPACE_END

package/dist/node_modules/sharp/src/libvips/cplusplus/VError.cpp

@@ -0,0 +1,50 @@
+// Code for error type
+
+/*
+
+    Copyright (C) 1991-2001 The National Gallery
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301  USA
+
+ */
+
+/*
+
+    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /*HAVE_CONFIG_H*/
+#include <vips/intl.h>
+
+#include <vips/vips8>
+
+VIPS_NAMESPACE_START
+
+std::ostream &operator<<( std::ostream &file, const VError &err )
+{
+	err.ostream_print( file );
+	return( file );
+}
+
+void VError::ostream_print( std::ostream &file ) const
+{
+	file << _what;
+}
+
+VIPS_NAMESPACE_END