koffi 2.7.2 → 2.7.3

package/vendor/node-addon-api/doc/setup.md

@@ -17,84 +17,66 @@ To use **Node-API** in a native module:
 
   1. Add a dependency on this package to `package.json`:
 
-```json
-  "dependencies": {
-    "node-addon-api": "*",
-  }
-```
-
-  2. Reference this package's include directory and gyp file in `binding.gyp`:
-
-```gyp
-  'include_dirs': ["<!(node -p \"require('node-addon-api').include_dir\")"],
-```
-
-  3. Decide whether the package will enable C++ exceptions in the Node-API wrapper.
+     ```json
+       "dependencies": {
+         "node-addon-api": "*",
+       }
+     ```
+
+  2. Decide whether the package will enable C++ exceptions in the Node-API
+     wrapper, and reference this package as a dependency in `binding.gyp`.
      The base ABI-stable C APIs do not throw or handle C++ exceptions, but the
      Node-API C++ wrapper classes may _optionally_
      [integrate C++ and JavaScript exception-handling
      ](https://github.com/nodejs/node-addon-api/blob/HEAD/doc/error_handling.md).
-     To enable that capability, C++ exceptions must be enabled in `binding.gyp`:
-
-```gyp
-  'cflags!': [ '-fno-exceptions' ],
-  'cflags_cc!': [ '-fno-exceptions' ],
-  'conditions': [
-    ["OS=='win'", {
-      "defines": [
-        "_HAS_EXCEPTIONS=1"
-      ],
-      "msvs_settings": {
-        "VCCLCompilerTool": {
-          "ExceptionHandling": 1
-        },
-      },
-    }],
-    ["OS=='mac'", {
-      'xcode_settings': {
-        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
-        'CLANG_CXX_LIBRARY': 'libc++',
-        'MACOSX_DEPLOYMENT_TARGET': '10.7',
-      },
-    }],
-  ],
-```
-
-  Alternatively, disable use of C++ exceptions in Node-API:
-
-```gyp
-  'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
-```
-
-  If you decide to use node-addon-api without C++ exceptions enabled, please
-  consider enabling node-addon-api safe API type guards to ensure the proper
-  exception handling pattern:
-
-```gyp
-  'defines': [ 'NODE_ADDON_API_ENABLE_MAYBE' ],
-```
-
-  4. If you would like your native addon to support OSX, please also add the
-  following settings in the `binding.gyp` file:
-
-  ```gyp
-  'conditions': [
-    ['OS=="mac"', {
-        'cflags+': ['-fvisibility=hidden'],
-        'xcode_settings': {
-          'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden
-        }
-    }]
-  ]
-  ```
-
-  5. Include `napi.h` in the native module code.
+
+     To use without C++ exceptions, add the following to `binding.gyp`:
+
+     ```gyp
+       'dependencies': [
+         "<!(node -p \"require('node-addon-api').targets\"):node_addon_api",
+       ],
+     ```
+
+     To enable that capability, add an alternative dependency in `binding.gyp`:
+
+     ```gyp
+       'dependencies': [
+         "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+       ],
+     ```
+
+     If you decide to use node-addon-api without C++ exceptions enabled, please
+     consider enabling node-addon-api safe API type guards to ensure the proper
+     exception handling pattern:
+
+     ```gyp
+       'dependencies': [
+         "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_maybe",
+       ],
+     ```
+
+  3. If you would like your native addon to support OSX, please also add the
+     following settings in the `binding.gyp` file:
+
+       ```gyp
+       'conditions': [
+         ['OS=="mac"', {
+             'cflags+': ['-fvisibility=hidden'],
+             'xcode_settings': {
+               'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden
+             }
+         }]
+       ]
+       ```
+
+  4. Include `napi.h` in the native module code.
      To ensure only ABI-stable APIs are used, DO NOT include
      `node.h`, `nan.h`, or `v8.h`.
 
-```C++
-#include "napi.h"
-```
+     ```C++
+     #include "napi.h"
+     ```
 
 At build time, the Node-API back-compat library code will be used only when the
 targeted node version *does not* have Node-API built-in.

package/vendor/node-addon-api/doc/syntax_error.md

@@ -0,0 +1,66 @@
+# SyntaxError
+
+The `Napi::SyntaxError` class is a representation of the JavaScript
+`SyntaxError` that is thrown when the engine encounters tokens or token order
+that does not conform to the syntax of the language when parsing code.
+
+The `Napi::SyntaxError` class inherits its behaviors from the `Napi::Error`
+class (for more info see: [`Napi::Error`](error.md)).
+
+For more details about error handling refer to the section titled [Error
+handling](error_handling.md).
+
+## Methods
+
+### New
+
+Creates a new instance of a `Napi::SyntaxError` object.
+
+```cpp
+Napi::SyntaxError::New(Napi::Env env, const char* message);
+```
+
+- `[in] Env`: The environment in which to construct the `Napi::SyntaxError`
+  object.
+- `[in] message`: Null-terminated string to be used as the message for the
+  `Napi::SyntaxError`.
+
+Returns an instance of a `Napi::SyntaxError` object.
+
+### New
+
+Creates a new instance of a `Napi::SyntaxError` object.
+
+```cpp
+Napi::SyntaxError::New(Napi::Env env, const std::string& message);
+```
+
+- `[in] Env`: The environment in which to construct the `Napi::SyntaxError`
+  object.
+- `[in] message`: Reference string to be used as the message for the
+  `Napi::SyntaxError`.
+
+Returns an instance of a `Napi::SyntaxError` object.
+
+### Constructor
+
+Creates a new empty instance of a `Napi::SyntaxError`.
+
+```cpp
+Napi::SyntaxError::SyntaxError();
+```
+
+### Constructor
+
+Initializes a `Napi::SyntaxError` instance from an existing Javascript error
+object.
+
+```cpp
+Napi::SyntaxError::SyntaxError(napi_env env, napi_value value);
+```
+
+- `[in] Env`: The environment in which to construct the `Napi::SyntaxError`
+  object.
+- `[in] value`: The `Napi::Error` reference to wrap.
+
+Returns an instance of a `Napi::SyntaxError` object.

package/vendor/node-addon-api/doc/value.md

@@ -141,6 +141,8 @@ bool Napi::Value::IsArrayBuffer() const;
 Returns `true` if the underlying value is a JavaScript `Napi::ArrayBuffer` or
 `false` otherwise.
 
+### IsBigInt
+
 ```cpp
 bool Napi::Value::IsBigInt() const;
 ```

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

@@ -5,7 +5,8 @@ const includeDir = path.relative('.', __dirname);
 module.exports = {
   include: `"${__dirname}"`, // deprecated, can be removed as part of 4.0.0
   include_dir: includeDir,
-  gyp: path.join(includeDir, 'node_api.gyp:nothing'),
+  gyp: path.join(includeDir, 'node_api.gyp:nothing'), // deprecated.
+  targets: path.join(includeDir, 'node_addon_api.gyp'),
   isNodeApiBuiltin: true,
   needsFlag: false
 };

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.