sharp 0.24.0 → 0.25.2

package/README.md

@@ -20,8 +20,7 @@ Lanczos resampling ensures quality is not sacrificed for speed.
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most modern 64-bit macOS, Windows and Linux systems running
-Node versions 10, 12 and 13
+Most modern macOS, Windows and Linux systems running Node.js v10+
 do not require any additional install or runtime dependencies.
 
 ## Examples
@@ -90,10 +89,10 @@ readableStream
 ### Documentation
 
 Visit [sharp.pixelplumbing.com](https://sharp.pixelplumbing.com/) for complete
-[installation instructions](https://sharp.pixelplumbing.com/page/install),
-[API documentation](https://sharp.pixelplumbing.com/page/api),
-[benchmark tests](https://sharp.pixelplumbing.com/page/performance) and
-[changelog](https://sharp.pixelplumbing.com/page/changelog).
+[installation instructions](https://sharp.pixelplumbing.com/install),
+[API documentation](https://sharp.pixelplumbing.com/api-constructor),
+[benchmark tests](https://sharp.pixelplumbing.com/performance) and
+[changelog](https://sharp.pixelplumbing.com/changelog).
 
 ### Contributing
 

package/binding.gyp

@@ -30,6 +30,9 @@
             'msvs_settings': {
               'VCCLCompilerTool': {
                 'ExceptionHandling': 1
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false'
               }
             },
             'msvs_disabled_warnings': [
@@ -44,7 +47,11 @@
     ]
   }, {
     'target_name': 'sharp',
+    'defines': [
+      'NAPI_VERSION=3'
+    ],
     'dependencies': [
+      '<!(node -p "require(\'node-addon-api\').gyp")',
       'libvips-cpp'
     ],
     'variables': {
@@ -65,11 +72,11 @@
       'src/stats.cc',
       'src/operations.cc',
       'src/pipeline.cc',
-      'src/sharp.cc',
-      'src/utilities.cc'
+      'src/utilities.cc',
+      'src/sharp.cc'
     ],
     'include_dirs': [
-      '<!(node -e "require(\'nan\')")'
+      '<!@(node -p "require(\'node-addon-api\').include")',
     ],
     'conditions': [
       ['use_global_libvips == "true"', {
@@ -189,10 +196,18 @@
               '-Wno-cast-function-type'
             ]
           }],
+          ['target_arch == "arm"', {
+            'cflags_cc': [
+              '-Wno-psabi'
+            ]
+          }],
           ['OS == "win"', {
             'msvs_settings': {
               'VCCLCompilerTool': {
                 'ExceptionHandling': 1
+              },
+              'VCLinkerTool': {
+                'ImageHasSafeExceptionHandlers': 'false'
               }
             },
             'msvs_disabled_warnings': [

package/install/libvips.js

@@ -14,8 +14,14 @@ const agent = require('../lib/agent');
 const libvips = require('../lib/libvips');
 const platform = require('../lib/platform');
 
-const minimumLibvipsVersion = libvips.minimumLibvipsVersion;
-const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `https://github.com/lovell/sharp-libvips/releases/download/v${minimumLibvipsVersion}/`;
+const minimumGlibcVersionByArch = {
+  arm: '2.28',
+  arm64: '2.29',
+  x64: '2.17'
+};
+
+const { minimumLibvipsVersion, minimumLibvipsVersionLabelled } = libvips;
+const distBaseUrl = process.env.npm_config_sharp_dist_base_url || process.env.SHARP_DIST_BASE_URL || `https://github.com/lovell/sharp-libvips/releases/download/v${minimumLibvipsVersionLabelled}/`;
 
 const fail = function (err) {
   npmLog.error('sharp', err.message);
@@ -57,18 +63,14 @@ try {
     // Is this arch/platform supported?
     const arch = process.env.npm_config_arch || process.arch;
     const platformAndArch = platform();
-    if (platformAndArch === 'win32-ia32') {
-      throw new Error('Windows x86 (32-bit) node.exe is not supported');
-    }
-    if (arch === 'ia32') {
+    if (arch === 'ia32' && !platformAndArch.startsWith('win32')) {
       throw new Error(`Intel Architecture 32-bit systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
     if (platformAndArch === 'freebsd-x64' || platformAndArch === 'openbsd-x64' || platformAndArch === 'sunos-x64') {
       throw new Error(`BSD/SunOS systems require manual installation of libvips >= ${minimumLibvipsVersion}`);
     }
     if (detectLibc.family === detectLibc.GLIBC && detectLibc.version) {
-      const minimumGlibcVersion = arch === 'arm64' ? '2.29.0' : '2.17.0';
-      if (semver.lt(`${detectLibc.version}.0`, minimumGlibcVersion)) {
+      if (semver.lt(`${detectLibc.version}.0`, `${minimumGlibcVersionByArch[arch]}.0`)) {
         throw new Error(`Use with glibc ${detectLibc.version} requires manual installation of libvips >= ${minimumLibvipsVersion}`);
       }
     }

package/lib/channel.js

@@ -54,9 +54,10 @@ function ensureAlpha () {
  * @example
  * sharp(input)
  *   .extractChannel('green')
- *   .toFile('input_green.jpg', function(err, info) {
+ *   .toColourspace('b-w')
+ *   .toFile('green.jpg', function(err, info) {
  *     // info.channels === 1
- *     // input_green.jpg contains the green channel of the input image
+ *     // green.jpg is a greyscale image containing the green channel of the input
  *    });
  *
  * @param {Number|String} channel - zero-indexed band number to extract, or `red`, `green` or `blue` as alternative to `0`, `1` or `2` respectively.

package/lib/composite.js

@@ -100,8 +100,7 @@ function composite (images) {
     if (!is.object(image)) {
       throw is.invalidParameterError('image to composite', 'object', image);
     }
-    const { raw, density } = image;
-    const inputOptions = (raw || density) ? { raw, density } : undefined;
+    const inputOptions = this._inputOptionsFromObject(image);
     const composite = {
       input: this._createInputDescriptor(image.input, inputOptions, { allowStream: false }),
       blend: 'over',

package/lib/constructor.js

@@ -16,6 +16,8 @@ try {
     help.push('- Ensure the version of Node.js used at install time matches that used at runtime');
   } else if (/invalid ELF header/.test(err.message)) {
     help.push(`- Ensure "${process.platform}" is used at install time as well as runtime`);
+  } else if (/dylib/.test(err.message) && /Incompatible library version/.test(err.message)) {
+    help.push('- Run "brew update && brew upgrade vips"');
   } else if (/Cannot find module/.test(err.message)) {
     help.push('- Run "npm rebuild --verbose sharp" and look for errors');
   } else {
@@ -161,7 +163,7 @@ const Sharp = function (input, options) {
     gamma: 0,
     gammaOut: 0,
     greyscale: false,
-    normalise: 0,
+    normalise: false,
     brightness: 1,
     saturation: 1,
     hue: 0,
@@ -217,6 +219,11 @@ const Sharp = function (input, options) {
     heifCompression: 'hevc',
     tileSize: 256,
     tileOverlap: 0,
+    tileContainer: 'fs',
+    tileLayout: 'dz',
+    tileFormat: 'last',
+    tileDepth: 'last',
+    tileAngle: 0,
     tileSkipBlanks: -1,
     tileBackground: [255, 255, 255, 255],
     linearA: 1,

package/lib/input.js

@@ -1,10 +1,20 @@
 'use strict';
 
-const util = require('util');
 const color = require('color');
 const is = require('./is');
 const sharp = require('../build/Release/sharp.node');
 
+/**
+ * Extract input options, if any, from an object.
+ * @private
+ */
+function _inputOptionsFromObject (obj) {
+  const { raw, density, limitInputPixels, sequentialRead, failOnError } = obj;
+  return [raw, density, limitInputPixels, sequentialRead, failOnError].some(is.defined)
+    ? { raw, density, limitInputPixels, sequentialRead, failOnError }
+    : undefined;
+}
+
 /**
  * Create Object containing input and input-related options.
  * @private
@@ -24,12 +34,12 @@ function _createInputDescriptor (input, inputOptions, containerOptions) {
   } else if (is.plainObject(input) && !is.defined(inputOptions)) {
     // Plain Object descriptor, e.g. create
     inputOptions = input;
-    if (is.plainObject(inputOptions.raw) || is.bool(inputOptions.failOnError)) {
-      // Raw Stream
+    if (_inputOptionsFromObject(inputOptions)) {
+      // Stream with options
       inputDescriptor.buffer = [];
     }
   } else if (!is.defined(input) && !is.defined(inputOptions) && is.object(containerOptions) && containerOptions.allowStream) {
-    // Stream
+    // Stream without options
     inputDescriptor.buffer = [];
   } else {
     throw new Error(`Unsupported input '${input}' of type ${typeof input}${
@@ -187,9 +197,9 @@ function _isStreamInput () {
  * - `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)
  * - `height`: Number of pixels high (EXIF orientation is not taken into consideration)
- * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L636)
+ * - `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `cmyk`, `lab`, `b-w` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation)
  * - `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://github.com/libvips/libvips/blob/master/libvips/iofuncs/enumtypes.c#L672)
+ * - `depth`: Name of pixel depth format e.g. `uchar`, `char`, `ushort`, `float` [...](https://libvips.github.io/libvips/API/current/VipsImage.html#VipsBandFormat)
  * - `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
@@ -278,7 +288,7 @@ function metadata (callback) {
  *     - `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`: Value to identify if the image is opaque or transparent, based on the presence and use of alpha channel
+ * - `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 (experimental)
  *
  * @example
@@ -331,32 +341,6 @@ function stats (callback) {
   }
 }
 
-/**
- * @private
- */
-const limitInputPixels = util.deprecate(function limitInputPixels (limit) {
-  // if we pass in false we represent the integer as 0 to disable
-  if (limit === false) {
-    limit = 0;
-  } else if (limit === true) {
-    limit = Math.pow(0x3FFF, 2);
-  }
-  if (is.integer(limit) && limit >= 0) {
-    this.options.input.limitInputPixels = limit;
-  } else {
-    throw is.invalidParameterError('limitInputPixels', 'integer', limit);
-  }
-  return this;
-}, 'limitInputPixels is deprecated, use sharp(input, { limitInputPixels: false }) instead');
-
-/**
- * @private
- */
-const sequentialRead = util.deprecate(function sequentialRead (sequentialRead) {
-  this.options.input.sequentialRead = is.bool(sequentialRead) ? sequentialRead : true;
-  return this;
-}, 'sequentialRead is deprecated, use sharp(input, { sequentialRead: true }) instead');
-
 /**
  * Decorate the Sharp prototype with input-related functions.
  * @private
@@ -364,15 +348,13 @@ const sequentialRead = util.deprecate(function sequentialRead (sequentialRead) {
 module.exports = function (Sharp) {
   Object.assign(Sharp.prototype, {
     // Private
+    _inputOptionsFromObject,
     _createInputDescriptor,
     _write,
     _flattenBufferIn,
     _isStreamInput,
     // Public
     metadata,
-    stats,
-    // Deprecated
-    limitInputPixels,
-    sequentialRead
+    stats
   });
 };

package/lib/libvips.js

@@ -8,8 +8,9 @@ const semver = require('semver');
 const platform = require('./platform');
 
 const env = process.env;
-const minimumLibvipsVersion = env.npm_package_config_libvips || /* istanbul ignore next */
+const minimumLibvipsVersionLabelled = env.npm_package_config_libvips || /* istanbul ignore next */
   require('../package.json').config.libvips;
+const minimumLibvipsVersion = semver.coerce(minimumLibvipsVersionLabelled).version;
 
 const spawnSyncOptions = {
   encoding: 'utf8',
@@ -93,11 +94,12 @@ const useGlobalLibvips = function () {
 };
 
 module.exports = {
-  minimumLibvipsVersion: minimumLibvipsVersion,
-  cachePath: cachePath,
-  globalLibvipsVersion: globalLibvipsVersion,
-  hasVendoredLibvips: hasVendoredLibvips,
-  pkgConfigPath: pkgConfigPath,
-  useGlobalLibvips: useGlobalLibvips,
-  mkdirSync: mkdirSync
+  minimumLibvipsVersion,
+  minimumLibvipsVersionLabelled,
+  cachePath,
+  globalLibvipsVersion,
+  hasVendoredLibvips,
+  pkgConfigPath,
+  useGlobalLibvips,
+  mkdirSync
 };

package/lib/output.js

@@ -517,7 +517,9 @@ function heif (options) {
 }
 
 /**
- * Force output to be raw, uncompressed uint8 pixel data.
+ * Force output to be raw, uncompressed, 8-bit unsigned integer (unit8) 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 RGB pixel data from JPEG input
@@ -525,6 +527,15 @@ function heif (options) {
  *   .raw()
  *   .toBuffer({ resolveWithObject: true });
  *
+ * @example
+ * // Extract alpha channel as raw pixel data from PNG input
+ * const data = await sharp('input.png')
+ *   .ensureAlpha()
+ *   .extractChannel(3)
+ *   .colourspace('b-w')
+ *   .raw()
+ *   .toBuffer();
+ *
  * @returns {Sharp}
  */
 function raw () {
@@ -557,7 +568,7 @@ function raw () {
  * @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, a value 0 - 255 for 8-bit images or 0 - 65535 for 16-bit images
  * @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`, `zoomify` or `google`.
+ * @param {String} [options.layout='dz'] filesystem layout, possible values are `dz`, `iiif`, `zoomify` or `google`.
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
@@ -592,10 +603,10 @@ function tile (options) {
     }
     // Layout
     if (is.defined(options.layout)) {
-      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'zoomify'])) {
+      if (is.string(options.layout) && is.inArray(options.layout, ['dz', 'google', 'iiif', 'zoomify'])) {
         this.options.tileLayout = options.layout;
       } else {
-        throw is.invalidParameterError('layout', 'one of: dz, google, zoomify', options.layout);
+        throw is.invalidParameterError('layout', 'one of: dz, google, iiif, zoomify', options.layout);
       }
     }
     // Angle of rotation,

package/lib/resize.js

@@ -85,21 +85,30 @@ const mapFitToCanvas = {
   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`: Crop to cover both provided dimensions (the default).
- * - `contain`: Embed within both provided dimensions.
+ * - `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
@@ -367,7 +376,7 @@ function extract (options) {
     }
   }, this);
   // Ensure existing rotation occurs before pre-resize extraction
-  if (suffix === 'Pre' && ((this.options.angle % 360) !== 0 || this.options.useExifOrientation === true || this.options.rotationAngle !== 0)) {
+  if (suffix === 'Pre' && isRotationExpected(this.options)) {
     this.options.rotateBeforePreExtract = true;
   }
   return this;
@@ -391,6 +400,9 @@ function trim (threshold) {
   } else {
     throw is.invalidParameterError('threshold', 'number greater than zero', threshold);
   }
+  if (this.options.trimThreshold && isRotationExpected(this.options)) {
+    this.options.rotateBeforePreExtract = true;
+  }
   return this;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
-  "version": "0.24.0",
+  "version": "0.25.2",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -65,10 +65,11 @@
     "Andargor <andargor@yahoo.com>",
     "Paul Neave <paul.neave@gmail.com>",
     "Brendan Kennedy <brenwken@gmail.com>",
-    "Brychan Bennett-Odlum <git@brychan.io>"
+    "Brychan Bennett-Odlum <git@brychan.io>",
+    "Edward Silverton <e.silverton@gmail.com>"
   ],
   "scripts": {
-    "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node-gyp rebuild && node install/dll-copy)",
+    "install": "(node install/libvips && node install/dll-copy && prebuild-install --runtime=napi) || (node-gyp rebuild && node install/dll-copy)",
     "clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
     "test": "semistandard && cpplint && npm run test-unit && npm run test-licensing && prebuild-ci",
     "test-unit": "nyc --reporter=lcov --branches=99 mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
@@ -109,40 +110,45 @@
   "dependencies": {
     "color": "^3.1.2",
     "detect-libc": "^1.0.3",
-    "nan": "^2.14.0",
+    "node-addon-api": "^2.0.0",
     "npmlog": "^4.1.2",
     "prebuild-install": "^5.3.3",
-    "semver": "^7.1.1",
+    "semver": "^7.1.3",
     "simple-get": "^3.1.0",
-    "tar": "^5.0.5",
+    "tar": "^6.0.1",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^3.1.0",
+    "async": "^3.2.0",
     "cc": "^2.0.1",
     "decompress-zip": "^0.3.2",
     "documentation": "^12.1.4",
     "exif-reader": "^1.0.3",
     "icc": "^1.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^7.0.0",
-    "mock-fs": "^4.10.4",
+    "mocha": "^7.1.1",
+    "mock-fs": "^4.11.0",
     "nyc": "^15.0.0",
     "prebuild": "^10.0.0",
     "prebuild-ci": "^3.1.0",
-    "rimraf": "^3.0.0",
+    "rimraf": "^3.0.2",
     "semistandard": "^14.2.0"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.9.0"
+    "libvips": "8.9.1"
   },
   "engines": {
-    "node": ">=10.13.0"
+    "node": ">=10"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"
   },
+  "binary": {
+    "napi_versions": [
+      3
+    ]
+  },
   "semistandard": {
     "env": [
       "mocha"

package/src/common.cc

@@ -19,9 +19,7 @@
 #include <queue>
 #include <mutex>  // NOLINT(build/c++11)
 
-#include <node.h>
-#include <node_buffer.h>
-#include <nan.h>
+#include <napi.h>
 #include <vips/vips8>
 
 #include "common.h"
@@ -30,66 +28,77 @@ using vips::VImage;
 
 namespace sharp {
 
-  // Convenience methods to access the attributes of a v8::Object
-  bool HasAttr(v8::Local<v8::Object> obj, std::string attr) {
-    return Nan::Has(obj, Nan::New(attr).ToLocalChecked()).FromJust();
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr) {
+    return obj.Has(attr);
   }
-  std::string AttrAsStr(v8::Local<v8::Object> obj, std::string attr) {
-    return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
+  std::string AttrAsStr(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::String>();
   }
-  std::vector<double> AttrAsRgba(v8::Local<v8::Object> obj, std::string attr) {
-    v8::Local<v8::Object> background = AttrAs<v8::Object>(obj, attr);
-    std::vector<double> rgba(4);
-    for (unsigned int i = 0; i < 4; i++) {
-      rgba[i] = AttrTo<double>(background, i);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().Uint32Value();
+  }
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().Int32Value();
+  }
+  double AttrAsDouble(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Number>().DoubleValue();
+  }
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr) {
+    return obj.Get(attr).As<Napi::Number>().DoubleValue();
+  }
+  bool AttrAsBool(Napi::Object obj, std::string attr) {
+    return obj.Get(attr).As<Napi::Boolean>().Value();
+  }
+  std::vector<double> AttrAsRgba(Napi::Object obj, std::string attr) {
+    Napi::Array background = obj.Get(attr).As<Napi::Array>();
+    std::vector<double> rgba(background.Length());
+    for (unsigned int i = 0; i < background.Length(); i++) {
+      rgba[i] = AttrAsDouble(background, i);
     }
     return rgba;
   }
 
-  // Create an InputDescriptor instance from a v8::Object describing an input image
-  InputDescriptor* CreateInputDescriptor(
-    v8::Local<v8::Object> input, std::vector<v8::Local<v8::Object>> &buffersToPersist
-  ) {
-    Nan::HandleScope();
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input) {
     InputDescriptor *descriptor = new InputDescriptor;
     if (HasAttr(input, "file")) {
       descriptor->file = AttrAsStr(input, "file");
     } else if (HasAttr(input, "buffer")) {
-      v8::Local<v8::Object> buffer = AttrAs<v8::Object>(input, "buffer");
-      descriptor->bufferLength = node::Buffer::Length(buffer);
-      descriptor->buffer = node::Buffer::Data(buffer);
+      Napi::Buffer<char> buffer = input.Get("buffer").As<Napi::Buffer<char>>();
+      descriptor->bufferLength = buffer.Length();
+      descriptor->buffer = buffer.Data();
       descriptor->isBuffer = TRUE;
-      buffersToPersist.push_back(buffer);
     }
-    descriptor->failOnError = AttrTo<bool>(input, "failOnError");
+    descriptor->failOnError = AttrAsBool(input, "failOnError");
     // Density for vector-based input
     if (HasAttr(input, "density")) {
-      descriptor->density = AttrTo<double>(input, "density");
+      descriptor->density = AttrAsDouble(input, "density");
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
-      descriptor->rawChannels = AttrTo<uint32_t>(input, "rawChannels");
-      descriptor->rawWidth = AttrTo<uint32_t>(input, "rawWidth");
-      descriptor->rawHeight = AttrTo<uint32_t>(input, "rawHeight");
+      descriptor->rawChannels = AttrAsUint32(input, "rawChannels");
+      descriptor->rawWidth = AttrAsUint32(input, "rawWidth");
+      descriptor->rawHeight = AttrAsUint32(input, "rawHeight");
     }
     // Multi-page input (GIF, TIFF, PDF)
     if (HasAttr(input, "pages")) {
-      descriptor->pages = AttrTo<int32_t>(input, "pages");
+      descriptor->pages = AttrAsInt32(input, "pages");
     }
     if (HasAttr(input, "page")) {
-      descriptor->page = AttrTo<uint32_t>(input, "page");
+      descriptor->page = AttrAsUint32(input, "page");
     }
     // Create new image
     if (HasAttr(input, "createChannels")) {
-      descriptor->createChannels = AttrTo<uint32_t>(input, "createChannels");
-      descriptor->createWidth = AttrTo<uint32_t>(input, "createWidth");
-      descriptor->createHeight = AttrTo<uint32_t>(input, "createHeight");
+      descriptor->createChannels = AttrAsUint32(input, "createChannels");
+      descriptor->createWidth = AttrAsUint32(input, "createWidth");
+      descriptor->createHeight = AttrAsUint32(input, "createHeight");
       descriptor->createBackground = AttrAsRgba(input, "createBackground");
     }
     // Limit input images to a given number of pixels, where pixels = width * height
-    descriptor->limitInputPixels = AttrTo<uint32_t>(input, "limitInputPixels");
+    descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
     // Allow switch from random to sequential access
-    descriptor->access = AttrTo<bool>(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
     return descriptor;
   }
 
@@ -439,11 +448,9 @@ namespace sharp {
   /*
     Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
   */
-  void FreeCallback(char* data, void* hint) {
-    if (data != nullptr) {
-      g_free(data);
-    }
-  }
+  std::function<void(void*, char*)> FreeCallback = [](void*, char* data) {
+    g_free(data);
+  };
 
   /*
     Temporary buffer of warnings