koffi 2.7.1 → 2.7.3

package/vendor/node-addon-api/napi-inl.h

@@ -31,22 +31,22 @@ namespace details {
 // Node.js releases. Only necessary when they are used in napi.h and napi-inl.h.
 constexpr int napi_no_external_buffers_allowed = 22;
 
+template <typename FreeType>
+inline void default_finalizer(napi_env /*env*/, void* data, void* /*hint*/) {
+  delete static_cast<FreeType*>(data);
+}
+
 // Attach a data item to an object and delete it when the object gets
 // garbage-collected.
 // TODO: Replace this code with `napi_add_finalizer()` whenever it becomes
 // available on all supported versions of Node.js.
-template <typename FreeType>
+template <typename FreeType,
+          napi_finalize finalizer = default_finalizer<FreeType>>
 inline napi_status AttachData(napi_env env,
                               napi_value obj,
                               FreeType* data,
-                              napi_finalize finalizer = nullptr,
                               void* hint = nullptr) {
   napi_status status;
-  if (finalizer == nullptr) {
-    finalizer = [](napi_env /*env*/, void* data, void* /*hint*/) {
-      delete static_cast<FreeType*>(data);
-    };
-  }
 #if (NAPI_VERSION < 5)
   napi_value symbol, external;
   status = napi_create_symbol(env, nullptr, &symbol);
@@ -263,10 +263,12 @@ struct ThreadSafeFinalize {
 template <typename ContextType, typename DataType, typename CallJs, CallJs call>
 inline typename std::enable_if<call != static_cast<CallJs>(nullptr)>::type
 CallJsWrapper(napi_env env, napi_value jsCallback, void* context, void* data) {
-  call(env,
-       Function(env, jsCallback),
-       static_cast<ContextType*>(context),
-       static_cast<DataType*>(data));
+  details::WrapVoidCallback([&]() {
+    call(env,
+         Function(env, jsCallback),
+         static_cast<ContextType*>(context),
+         static_cast<DataType*>(data));
+  });
 }
 
 template <typename ContextType, typename DataType, typename CallJs, CallJs call>
@@ -275,9 +277,11 @@ CallJsWrapper(napi_env env,
               napi_value jsCallback,
               void* /*context*/,
               void* /*data*/) {
-  if (jsCallback != nullptr) {
-    Function(env, jsCallback).Call(0, nullptr);
-  }
+  details::WrapVoidCallback([&]() {
+    if (jsCallback != nullptr) {
+      Function(env, jsCallback).Call(0, nullptr);
+    }
+  });
 }
 
 #if NAPI_VERSION > 4
@@ -572,6 +576,14 @@ void Env::DefaultFiniWithHint(Env, DataType* data, HintType*) {
 }
 #endif  // NAPI_VERSION > 5
 
+#if NAPI_VERSION > 8
+inline const char* Env::GetModuleFileName() const {
+  const char* result;
+  napi_status status = node_api_get_module_file_name(_env, &result);
+  NAPI_THROW_IF_FAILED(*this, status, nullptr);
+  return result;
+}
+#endif  // NAPI_VERSION > 8
 ////////////////////////////////////////////////////////////////////////////////
 // Value class
 ////////////////////////////////////////////////////////////////////////////////
@@ -1624,11 +1636,8 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) const {
       new details::FinalizeData<T, Finalizer>(
           {std::move(finalizeCallback), nullptr});
   napi_status status =
-      details::AttachData(_env,
-                          *this,
-                          data,
-                          details::FinalizeData<T, Finalizer>::Wrapper,
-                          finalizeData);
+      details::AttachData<T, details::FinalizeData<T, Finalizer>::Wrapper>(
+          _env, *this, data, finalizeData);
   if (status != napi_ok) {
     delete finalizeData;
     NAPI_THROW_IF_FAILED_VOID(_env, status);
@@ -1642,12 +1651,9 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
       new details::FinalizeData<T, Finalizer, Hint>(
           {std::move(finalizeCallback), finalizeHint});
-  napi_status status = details::AttachData(
-      _env,
-      *this,
-      data,
-      details::FinalizeData<T, Finalizer, Hint>::WrapperWithHint,
-      finalizeData);
+  napi_status status = details::
+      AttachData<T, details::FinalizeData<T, Finalizer, Hint>::WrapperWithHint>(
+          _env, *this, data, finalizeData);
   if (status != napi_ok) {
     delete finalizeData;
     NAPI_THROW_IF_FAILED_VOID(_env, status);
@@ -2623,7 +2629,7 @@ inline Buffer<T> Buffer<T>::New(napi_env env, size_t length) {
   napi_status status =
       napi_create_buffer(env, length * sizeof(T), &data, &value);
   NAPI_THROW_IF_FAILED(env, status, Buffer<T>());
-  return Buffer(env, value, length, static_cast<T*>(data));
+  return Buffer(env, value);
 }
 
 #ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@@ -2633,7 +2639,7 @@ inline Buffer<T> Buffer<T>::New(napi_env env, T* data, size_t length) {
   napi_status status = napi_create_external_buffer(
       env, length * sizeof(T), data, nullptr, nullptr, &value);
   NAPI_THROW_IF_FAILED(env, status, Buffer<T>());
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 }
 
 template <typename T>
@@ -2657,7 +2663,7 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, Buffer());
   }
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 }
 
 template <typename T>
@@ -2682,7 +2688,7 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, Buffer());
   }
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 }
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 
@@ -2699,7 +2705,7 @@ inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env, T* data, size_t length) {
 #ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
   }
   NAPI_THROW_IF_FAILED(env, status, Buffer<T>());
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 }
 
@@ -2733,7 +2739,7 @@ inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env,
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, Buffer());
   }
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 }
 
@@ -2769,7 +2775,7 @@ inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env,
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, Buffer());
   }
-  return Buffer(env, value, length, data);
+  return Buffer(env, value);
 #endif
 }
 
@@ -2793,42 +2799,20 @@ inline void Buffer<T>::CheckCast(napi_env env, napi_value value) {
 }
 
 template <typename T>
-inline Buffer<T>::Buffer() : Uint8Array(), _length(0), _data(nullptr) {}
+inline Buffer<T>::Buffer() : Uint8Array() {}
 
 template <typename T>
 inline Buffer<T>::Buffer(napi_env env, napi_value value)
-    : Uint8Array(env, value), _length(0), _data(nullptr) {}
-
-template <typename T>
-inline Buffer<T>::Buffer(napi_env env, napi_value value, size_t length, T* data)
-    : Uint8Array(env, value), _length(length), _data(data) {}
+    : Uint8Array(env, value) {}
 
 template <typename T>
 inline size_t Buffer<T>::Length() const {
-  EnsureInfo();
-  return _length;
+  return ByteLength() / sizeof(T);
 }
 
 template <typename T>
 inline T* Buffer<T>::Data() const {
-  EnsureInfo();
-  return _data;
-}
-
-template <typename T>
-inline void Buffer<T>::EnsureInfo() const {
-  // The Buffer instance may have been constructed from a napi_value whose
-  // length/data are not yet known. Fetch and cache these values just once,
-  // since they can never change during the lifetime of the Buffer.
-  if (_data == nullptr) {
-    size_t byteLength;
-    void* voidData;
-    napi_status status =
-        napi_get_buffer_info(_env, _value, &voidData, &byteLength);
-    NAPI_THROW_IF_FAILED_VOID(_env, status);
-    _length = byteLength / sizeof(T);
-    _data = static_cast<T*>(voidData);
-  }
+  return reinterpret_cast<T*>(const_cast<uint8_t*>(Uint8Array::Data()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3157,6 +3141,23 @@ inline RangeError::RangeError() : Error() {}
 inline RangeError::RangeError(napi_env env, napi_value value)
     : Error(env, value) {}
 
+#if NAPI_VERSION > 8
+inline SyntaxError SyntaxError::New(napi_env env, const char* message) {
+  return Error::New<SyntaxError>(
+      env, message, std::strlen(message), node_api_create_syntax_error);
+}
+
+inline SyntaxError SyntaxError::New(napi_env env, const std::string& message) {
+  return Error::New<SyntaxError>(
+      env, message.c_str(), message.size(), node_api_create_syntax_error);
+}
+
+inline SyntaxError::SyntaxError() : Error() {}
+
+inline SyntaxError::SyntaxError(napi_env env, napi_value value)
+    : Error(env, value) {}
+#endif  // NAPI_VERSION > 8
+
 ////////////////////////////////////////////////////////////////////////////////
 // Reference<T> class
 ////////////////////////////////////////////////////////////////////////////////
@@ -6110,13 +6111,15 @@ inline void ThreadSafeFunction::CallJS(napi_env env,
     return;
   }
 
-  if (data != nullptr) {
-    auto* callbackWrapper = static_cast<CallbackWrapper*>(data);
-    (*callbackWrapper)(env, Function(env, jsCallback));
-    delete callbackWrapper;
-  } else if (jsCallback != nullptr) {
-    Function(env, jsCallback).Call({});
-  }
+  details::WrapVoidCallback([&]() {
+    if (data != nullptr) {
+      auto* callbackWrapper = static_cast<CallbackWrapper*>(data);
+      (*callbackWrapper)(env, Function(env, jsCallback));
+      delete callbackWrapper;
+    } else if (jsCallback != nullptr) {
+      Function(env, jsCallback).Call({});
+    }
+  });
 }
 
 ////////////////////////////////////////////////////////////////////////////////

package/vendor/node-addon-api/napi.h

@@ -367,6 +367,10 @@ class Env {
     } * data;
   };
 #endif  // NAPI_VERSION > 2
+
+#if NAPI_VERSION > 8
+  const char* GetModuleFileName() const;
+#endif  // NAPI_VERSION > 8
 };
 
 /// A JavaScript value of unknown type.
@@ -1531,11 +1535,6 @@ class Buffer : public Uint8Array {
   T* Data() const;
 
  private:
-  mutable size_t _length;
-  mutable T* _data;
-
-  Buffer(napi_env env, napi_value value, size_t length, T* data);
-  void EnsureInfo() const;
 };
 
 /// Holds a counted reference to a value; initially a weak reference unless
@@ -1853,6 +1852,17 @@ class RangeError : public Error {
   RangeError(napi_env env, napi_value value);
 };
 
+#if NAPI_VERSION > 8
+class SyntaxError : public Error {
+ public:
+  static SyntaxError New(napi_env env, const char* message);
+  static SyntaxError New(napi_env env, const std::string& message);
+
+  SyntaxError();
+  SyntaxError(napi_env env, napi_value value);
+};
+#endif  // NAPI_VERSION > 8
+
 class CallbackInfo {
  public:
   CallbackInfo(napi_env env, napi_callback_info info);

package/vendor/node-addon-api/node_addon_api.gyp

@@ -0,0 +1,32 @@
+{
+  'targets': [
+    {
+      'target_name': 'node_addon_api',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_except',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_maybe',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+        'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
+      }
+    },
+  ]
+}

package/vendor/node-addon-api/package.json

@@ -407,6 +407,14 @@
     {
       "name": "Caleb Hearon",
       "url": "https://github.com/chearon"
+    },
+    {
+      "name": "Marx",
+      "url": "https://github.com/MarxJiao"
+    },
+    {
+      "name": "Ömer AKGÜL",
+      "url": "https://github.com/tuhalf"
     }
   ],
   "description": "Node.js API (Node-API)",
@@ -420,7 +428,7 @@
     "eslint-plugin-import": "^2.24.2",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^5.1.0",
-    "fs-extra": "^9.0.1",
+    "fs-extra": "^11.1.1",
     "path": "^0.12.7",
     "pre-commit": "^1.2.2",
     "safe-buffer": "^5.1.1"
@@ -467,6 +475,9 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "7.0.0",
-  "support": true
+  "version": "7.1.0",
+  "support": true,
+  "engines": {
+    "node": "^16 || ^18 || >= 20"
+  }
 }

package/vendor/node-addon-api/test/addon.cc

@@ -17,6 +17,8 @@ class TestAddon : public Napi::Addon<TestAddon> {
                  {InstanceMethod("decrement", &TestAddon::Decrement)}))});
   }
 
+  ~TestAddon() { fprintf(stderr, "TestAddon::~TestAddon\n"); }
+
  private:
   Napi::Value Increment(const Napi::CallbackInfo& info) {
     return Napi::Number::New(info.Env(), ++value);
@@ -29,10 +31,14 @@ class TestAddon : public Napi::Addon<TestAddon> {
   uint32_t value = 42;
 };
 
+Napi::Value CreateAddon(const Napi::CallbackInfo& info) {
+  return TestAddon::Init(info.Env(), Napi::Object::New(info.Env()));
+}
+
 }  // end of anonymous namespace
 
 Napi::Object InitAddon(Napi::Env env) {
-  return TestAddon::Init(env, Napi::Object::New(env));
+  return Napi::Function::New<CreateAddon>(env, "CreateAddon");
 }
 
 #endif  // (NAPI_VERSION > 5)

package/vendor/node-addon-api/test/addon.js

@@ -1,11 +1,7 @@
 'use strict';
 
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  assert.strictEqual(binding.addon.increment(), 43);
-  assert.strictEqual(binding.addon.increment(), 44);
-  assert.strictEqual(binding.addon.subObject.decrement(), 43);
-}
+module.exports = require('./common').runTestInChildProcess({
+  suite: 'addon',
+  testName: 'workingCode',
+  expectedStderr: ['TestAddon::~TestAddon']
+});

package/vendor/node-addon-api/test/addon_data.cc

@@ -4,10 +4,10 @@
 #include "test_helper.h"
 
 // An overly elaborate way to get/set a boolean stored in the instance data:
-// 0. A boolean named "verbose" is stored in the instance data. The constructor
-//    for JS `VerboseIndicator` instances is also stored in the instance data.
+// 0. The constructor for JS `VerboseIndicator` instances, which have a private
+//    member named "verbose", is stored in the instance data.
 // 1. Add a property named "verbose" onto exports served by a getter/setter.
-// 2. The getter returns a object of type VerboseIndicator, which itself has a
+// 2. The getter returns an object of type VerboseIndicator, which itself has a
 //    property named "verbose", also served by a getter/setter:
 //    * The getter returns a boolean, indicating whether "verbose" is set.
 //    * The setter sets "verbose" on the instance data.

package/vendor/node-addon-api/test/addon_data.js

@@ -1,46 +1,24 @@
 'use strict';
 
-const assert = require('assert');
-const { spawn } = require('child_process');
-const readline = require('readline');
+const common = require('./common');
 
-module.exports = require('./common').runTestWithBindingPath(test);
+module.exports = common.runTest(test);
 
-// Make sure the instance data finalizer is called at process exit. If the hint
-// is non-zero, it will be printed out by the child process.
-function testFinalizer (bindingName, hint, expected) {
-  return new Promise((resolve) => {
-    bindingName = bindingName.split('\\').join('\\\\');
-    const child = spawn(process.execPath, [
-      '-e',
-      `require('${bindingName}').addon_data(${hint}).verbose = true;`
-    ]);
-    const actual = [];
-    readline
-      .createInterface({ input: child.stderr })
-      .on('line', (line) => {
-        if (expected.indexOf(line) >= 0) {
-          actual.push(line);
-        }
-      })
-      .on('close', () => {
-        assert.deepStrictEqual(expected, actual);
-        resolve();
-      });
+async function test () {
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'workingCode'
   });
-}
-
-async function test (bindingName) {
-  const binding = require(bindingName).addon_data(0);
 
-  // Make sure it is possible to get/set instance data.
-  assert.strictEqual(binding.verbose.verbose, false);
-  binding.verbose = true;
-  assert.strictEqual(binding.verbose.verbose, true);
-  binding.verbose = false;
-  assert.strictEqual(binding.verbose.verbose, false);
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'cleanupWithoutHint',
+    expectedStderr: ['addon_data: Addon::~Addon']
+  });
 
-  await testFinalizer(bindingName, 0, ['addon_data: Addon::~Addon']);
-  await testFinalizer(bindingName, 42,
-    ['addon_data: Addon::~Addon', 'hint: 42']);
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'cleanupWithHint',
+    expectedStderr: ['addon_data: Addon::~Addon', 'hint: 42']
+  });
 }

package/vendor/node-addon-api/test/bigint.cc

@@ -1,6 +1,5 @@
 #if (NAPI_VERSION > 5)
 
-#define NAPI_EXPERIMENTAL
 #include "napi.h"
 
 #include "test_helper.h"

package/vendor/node-addon-api/test/binding.cc

@@ -50,12 +50,14 @@ Object InitPromise(Env env);
 Object InitRunScript(Env env);
 #if (NAPI_VERSION > 3)
 Object InitThreadSafeFunctionCtx(Env env);
+Object InitThreadSafeFunctionException(Env env);
 Object InitThreadSafeFunctionExistingTsfn(Env env);
 Object InitThreadSafeFunctionPtr(Env env);
 Object InitThreadSafeFunctionSum(Env env);
 Object InitThreadSafeFunctionUnref(Env env);
 Object InitThreadSafeFunction(Env env);
 Object InitTypedThreadSafeFunctionCtx(Env env);
+Object InitTypedThreadSafeFunctionException(Env env);
 Object InitTypedThreadSafeFunctionExistingTsfn(Env env);
 Object InitTypedThreadSafeFunctionPtr(Env env);
 Object InitTypedThreadSafeFunctionSum(Env env);
@@ -78,7 +80,9 @@ Object InitThunkingManual(Env env);
 Object InitObjectFreezeSeal(Env env);
 Object InitTypeTaggable(Env env);
 #endif
-
+#if (NAPI_VERSION > 8)
+Object InitEnvMiscellaneous(Env env);
+#endif
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
 Object InitMaybeCheck(Env env);
 #endif
@@ -137,6 +141,8 @@ Object Init(Env env, Object exports) {
   exports.Set("symbol", InitSymbol(env));
 #if (NAPI_VERSION > 3)
   exports.Set("threadsafe_function_ctx", InitThreadSafeFunctionCtx(env));
+  exports.Set("threadsafe_function_exception",
+              InitThreadSafeFunctionException(env));
   exports.Set("threadsafe_function_existing_tsfn",
               InitThreadSafeFunctionExistingTsfn(env));
   exports.Set("threadsafe_function_ptr", InitThreadSafeFunctionPtr(env));
@@ -145,6 +151,8 @@ Object Init(Env env, Object exports) {
   exports.Set("threadsafe_function", InitThreadSafeFunction(env));
   exports.Set("typed_threadsafe_function_ctx",
               InitTypedThreadSafeFunctionCtx(env));
+  exports.Set("typed_threadsafe_function_exception",
+              InitTypedThreadSafeFunctionException(env));
   exports.Set("typed_threadsafe_function_existing_tsfn",
               InitTypedThreadSafeFunctionExistingTsfn(env));
   exports.Set("typed_threadsafe_function_ptr",
@@ -171,6 +179,9 @@ Object Init(Env env, Object exports) {
   exports.Set("object_freeze_seal", InitObjectFreezeSeal(env));
   exports.Set("type_taggable", InitTypeTaggable(env));
 #endif
+#if (NAPI_VERSION > 8)
+  exports.Set("env_misc", InitEnvMiscellaneous(env));
+#endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
   exports.Set("maybe_check", InitMaybeCheck(env));

package/vendor/node-addon-api/test/binding.gyp

@@ -26,6 +26,7 @@
         'dataview/dataview.cc',
         'dataview/dataview_read_write.cc',
         'env_cleanup.cc',
+        'env_misc.cc',
         'error.cc',
         'error_handling_for_primitives.cc',
         'external.cc',
@@ -54,6 +55,7 @@
         'run_script.cc',
         'symbol.cc',
         'threadsafe_function/threadsafe_function_ctx.cc',
+        'threadsafe_function/threadsafe_function_exception.cc',
         'threadsafe_function/threadsafe_function_existing_tsfn.cc',
         'threadsafe_function/threadsafe_function_ptr.cc',
         'threadsafe_function/threadsafe_function_sum.cc',
@@ -61,6 +63,7 @@
         'threadsafe_function/threadsafe_function.cc',
         'type_taggable.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ctx.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_exception.cc',
         'typed_threadsafe_function/typed_threadsafe_function_existing_tsfn.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ptr.cc',
         'typed_threadsafe_function/typed_threadsafe_function_sum.cc',
@@ -94,41 +97,40 @@
   'targets': [
     {
       'target_name': 'binding',
-      'includes': ['../except.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_except'],
       'sources': ['>@(build_sources)']
     },
     {
       'target_name': 'binding_noexcept',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources)']
     },
     {
       'target_name': 'binding_noexcept_maybe',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_maybe'],
       'sources': ['>@(build_sources)'],
-      'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
     },
     {
       'target_name': 'binding_swallowexcept',
-      'includes': ['../except.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_except'],
       'sources': [ '>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
     {
       'target_name': 'binding_swallowexcept_noexcept',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
     {
       'target_name': 'binding_type_check',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources_type_check)'],
       'defines': ['NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS']
     },
     {
       'target_name': 'binding_custom_namespace',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources)'],
       'defines': ['NAPI_CPP_CUSTOM_NAMESPACE=cstm']
     },

package/vendor/node-addon-api/test/child_processes/addon.js

@@ -0,0 +1,11 @@
+'use strict';
+const assert = require('assert');
+
+module.exports = {
+  workingCode: binding => {
+    const addon = binding.addon();
+    assert.strictEqual(addon.increment(), 43);
+    assert.strictEqual(addon.increment(), 44);
+    assert.strictEqual(addon.subObject.decrement(), 43);
+  }
+};

package/vendor/node-addon-api/test/child_processes/addon_data.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const assert = require('assert');
+
+// Make sure the instance data finalizer is called at process exit. If the hint
+// is non-zero, it will be printed out by the child process.
+const cleanupTest = (binding, hint) => {
+  binding.addon_data(hint).verbose = true;
+};
+
+module.exports = {
+  workingCode: binding => {
+    const addonData = binding.addon_data(0);
+
+    // Make sure it is possible to get/set instance data.
+    assert.strictEqual(addonData.verbose.verbose, false);
+    addonData.verbose = true;
+    assert.strictEqual(addonData.verbose.verbose, true);
+    addonData.verbose = false;
+    assert.strictEqual(addonData.verbose.verbose, false);
+  },
+  cleanupWithHint: binding => cleanupTest(binding, 42),
+  cleanupWithoutHint: binding => cleanupTest(binding, 0)
+};