koffi 2.3.17 → 2.3.19

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

@@ -1,11 +1,22 @@
 #ifndef SRC_NAPI_H_
 #define SRC_NAPI_H_
 
+#ifndef NAPI_HAS_THREADS
+#if !defined(__wasm__) || (defined(__EMSCRIPTEN_PTHREADS__) ||                 \
+                           (defined(__wasi__) && defined(_REENTRANT)))
+#define NAPI_HAS_THREADS 1
+#else
+#define NAPI_HAS_THREADS 0
+#endif
+#endif
+
 #include <node_api.h>
 #include <functional>
 #include <initializer_list>
 #include <memory>
+#if NAPI_HAS_THREADS
 #include <mutex>
+#endif  // NAPI_HAS_THREADS
 #include <string>
 #include <vector>
 
@@ -452,6 +463,9 @@ class Value {
   ///
   /// This conversion does NOT coerce the type. Calling any methods
   /// inappropriate for the actual value type will throw `Napi::Error`.
+  ///
+  /// If `NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS` is defined, this method
+  /// asserts that the actual type is the expected type.
   template <typename T>
   T As() const;
 
@@ -478,6 +492,8 @@ class Boolean : public Value {
                      bool value     ///< Boolean value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Boolean();  ///< Creates a new _empty_ Boolean instance.
   Boolean(napi_env env,
           napi_value value);  ///< Wraps a Node-API value primitive.
@@ -493,6 +509,8 @@ class Number : public Value {
                     double value   ///< Number value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Number();  ///< Creates a new _empty_ Number instance.
   Number(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -541,6 +559,8 @@ class BigInt : public Value {
                     const uint64_t* words  ///< Array of words
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   BigInt();  ///< Creates a new _empty_ BigInt instance.
   BigInt(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -572,6 +592,8 @@ class Date : public Value {
                   double value   ///< Number value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Date();  ///< Creates a new _empty_ Date instance.
   Date(napi_env env, napi_value value);  ///< Wraps a Node-API value primitive.
   operator double() const;  ///< Converts a Date value to double primitive
@@ -583,6 +605,8 @@ class Date : public Value {
 /// A JavaScript string or symbol value (that can be used as a property name).
 class Name : public Value {
  public:
+  static void CheckCast(napi_env env, napi_value value);
+
   Name();  ///< Creates a new _empty_ Name instance.
   Name(napi_env env,
        napi_value value);  ///< Wraps a Node-API value primitive.
@@ -640,6 +664,8 @@ class String : public Name {
   template <typename T>
   static String From(napi_env env, const T& value);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   String();  ///< Creates a new _empty_ String instance.
   String(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -698,13 +724,26 @@ class Symbol : public Name {
   // Create a symbol in the global registry, napi_value describing the symbol
   static MaybeOrValue<Symbol> For(napi_env env, napi_value description);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Symbol();  ///< Creates a new _empty_ Symbol instance.
   Symbol(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
 };
 
+class TypeTaggable : public Value {
+ public:
+#if NAPI_VERSION >= 8
+  void TypeTag(const napi_type_tag* type_tag) const;
+  bool CheckTypeTag(const napi_type_tag* type_tag) const;
+#endif  // NAPI_VERSION >= 8
+ protected:
+  TypeTaggable();
+  TypeTaggable(napi_env env, napi_value value);
+};
+
 /// A JavaScript object value.
-class Object : public Value {
+class Object : public TypeTaggable {
  public:
   /// Enables property and element assignments using indexing syntax.
   ///
@@ -745,6 +784,8 @@ class Object : public Value {
   static Object New(napi_env env  ///< Node-API environment
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Object();  ///< Creates a new _empty_ Object instance.
   Object(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -980,14 +1021,11 @@ class Object : public Value {
   /// See
   /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
   MaybeOrValue<bool> Seal() const;
-
-  void TypeTag(const napi_type_tag* type_tag) const;
-  bool CheckTypeTag(const napi_type_tag* type_tag) const;
 #endif  // NAPI_VERSION >= 8
 };
 
 template <typename T>
-class External : public Value {
+class External : public TypeTaggable {
  public:
   static External New(napi_env env, T* data);
 
@@ -1001,6 +1039,8 @@ class External : public Value {
                       Finalizer finalizeCallback,
                       Hint* finalizeHint);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   External();
   External(napi_env env, napi_value value);
 
@@ -1012,6 +1052,8 @@ class Array : public Object {
   static Array New(napi_env env);
   static Array New(napi_env env, size_t length);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Array();
   Array(napi_env env, napi_value value);
 
@@ -1077,6 +1119,7 @@ class ArrayBuffer : public Object {
       size_t byteLength  ///< Length of the buffer to be allocated, in bytes
   );
 
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
   /// Creates a new ArrayBuffer instance, using an external buffer with
   /// specified byte length.
   static ArrayBuffer New(
@@ -1120,6 +1163,9 @@ class ArrayBuffer : public Object {
       Hint* finalizeHint  ///< Hint (second parameter) to be passed to the
                           ///< finalize callback
   );
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+  static void CheckCast(napi_env env, napi_value value);
 
   ArrayBuffer();  ///< Creates a new _empty_ ArrayBuffer instance.
   ArrayBuffer(napi_env env,
@@ -1145,6 +1191,8 @@ class ArrayBuffer : public Object {
 ///     }
 class TypedArray : public Object {
  public:
+  static void CheckCast(napi_env env, napi_value value);
+
   TypedArray();  ///< Creates a new _empty_ TypedArray instance.
   TypedArray(napi_env env,
              napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1245,6 +1293,8 @@ class TypedArrayOf : public TypedArray {
       ///< template parameter T.
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   TypedArrayOf();  ///< Creates a new _empty_ TypedArrayOf instance.
   TypedArrayOf(napi_env env,
                napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1289,6 +1339,8 @@ class DataView : public Object {
                       size_t byteOffset,
                       size_t byteLength);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   DataView();  ///< Creates a new _empty_ DataView instance.
   DataView(napi_env env,
            napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1369,6 +1421,8 @@ class Function : public Object {
                       const std::string& utf8name,
                       void* data = nullptr);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Function();
   Function(napi_env env, napi_value value);
 
@@ -1425,6 +1479,8 @@ class Promise : public Object {
     napi_value _promise;
   };
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Promise(napi_env env, napi_value value);
 };
 
@@ -1432,6 +1488,7 @@ template <typename T>
 class Buffer : public Uint8Array {
  public:
   static Buffer<T> New(napi_env env, size_t length);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
   static Buffer<T> New(napi_env env, T* data, size_t length);
 
   // Finalizer must implement `void operator()(Env env, T* data)`.
@@ -1447,9 +1504,27 @@ class Buffer : public Uint8Array {
                        size_t length,
                        Finalizer finalizeCallback,
                        Hint* finalizeHint);
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+  static Buffer<T> NewOrCopy(napi_env env, T* data, size_t length);
+  // Finalizer must implement `void operator()(Env env, T* data)`.
+  template <typename Finalizer>
+  static Buffer<T> NewOrCopy(napi_env env,
+                             T* data,
+                             size_t length,
+                             Finalizer finalizeCallback);
+  // Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`.
+  template <typename Finalizer, typename Hint>
+  static Buffer<T> NewOrCopy(napi_env env,
+                             T* data,
+                             size_t length,
+                             Finalizer finalizeCallback,
+                             Hint* finalizeHint);
 
   static Buffer<T> Copy(napi_env env, const T* data, size_t length);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Buffer();
   Buffer(napi_env env, napi_value value);
   size_t Length() const;
@@ -2435,6 +2510,7 @@ class AsyncContext {
   napi_async_context _context;
 };
 
+#if NAPI_HAS_THREADS
 class AsyncWorker {
  public:
   virtual ~AsyncWorker();
@@ -2497,8 +2573,9 @@ class AsyncWorker {
   std::string _error;
   bool _suppress_destruct;
 };
+#endif  // NAPI_HAS_THREADS
 
-#if (NAPI_VERSION > 3 && !defined(__wasm32__))
+#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS)
 class ThreadSafeFunction {
  public:
   // This API may only be called from the main thread.
@@ -3068,7 +3145,7 @@ class AsyncProgressQueueWorker
   void Signal() const;
   void SendProgress_(const T* data, size_t count);
 };
-#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
+#endif  // NAPI_VERSION > 3 && NAPI_HAS_THREADS
 
 // Memory management.
 class MemoryManagement {

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

@@ -247,6 +247,10 @@
       "name": "Mathias Küsel",
       "url": "https://github.com/mathiask88"
     },
+    {
+      "name": "Mathias Stearn",
+      "url": "https://github.com/RedBeard0531"
+    },
     {
       "name": "Matteo Collina",
       "url": "https://github.com/mcollina"
@@ -355,6 +359,10 @@
       "name": "todoroff",
       "url": "https://github.com/todoroff"
     },
+    {
+      "name": "Toyo Li",
+      "url": "https://github.com/toyobayashi"
+    },
     {
       "name": "Tux3",
       "url": "https://github.com/tux3"
@@ -451,6 +459,6 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "support": true
 }

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

@@ -34,11 +34,16 @@ class TestWorker : public AsyncProgressWorker<ProgressData> {
       SetError("test error");
     }
     ProgressData data{0};
-    std::unique_lock<std::mutex> lock(_cvm);
+
     for (int32_t idx = 0; idx < _times; idx++) {
       data.progress = idx;
       progress.Send(&data, 1);
-      _cv.wait(lock);
+
+      {
+        std::unique_lock<std::mutex> lk(_cvm);
+        _cv.wait(lk, [this] { return dataSent; });
+        dataSent = false;
+      }
     }
   }
 
@@ -48,7 +53,12 @@ class TestWorker : public AsyncProgressWorker<ProgressData> {
       Number progress = Number::New(env, data->progress);
       _progress.MakeCallback(Receiver().Value(), {progress});
     }
-    _cv.notify_one();
+
+    {
+      std::lock_guard<std::mutex> lk(_cvm);
+      dataSent = true;
+      _cv.notify_one();
+    }
   }
 
  private:
@@ -59,6 +69,8 @@ class TestWorker : public AsyncProgressWorker<ProgressData> {
       : AsyncProgressWorker(cb, resource_name, resource) {
     _progress.Reset(progress, 1);
   }
+
+  bool dataSent = false;
   std::condition_variable _cv;
   std::mutex _cvm;
   int32_t _times;

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

@@ -22,6 +22,7 @@ Object InitBasicTypesValue(Env env);
 Object InitBigInt(Env env);
 #endif
 Object InitBuffer(Env env);
+Object InitBufferNoExternal(Env env);
 #if (NAPI_VERSION > 2)
 Object InitCallbackScope(Env env);
 #endif
@@ -75,7 +76,7 @@ Object InitVersionManagement(Env env);
 Object InitThunkingManual(Env env);
 #if (NAPI_VERSION > 7)
 Object InitObjectFreezeSeal(Env env);
-Object InitObjectTypeTag(Env env);
+Object InitTypeTaggable(Env env);
 #endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
@@ -107,6 +108,7 @@ Object Init(Env env, Object exports) {
   exports.Set("date", InitDate(env));
 #endif
   exports.Set("buffer", InitBuffer(env));
+  exports.Set("bufferNoExternal", InitBufferNoExternal(env));
 #if (NAPI_VERSION > 2)
   exports.Set("callbackscope", InitCallbackScope(env));
 #endif
@@ -167,7 +169,7 @@ Object Init(Env env, Object exports) {
   exports.Set("thunking_manual", InitThunkingManual(env));
 #if (NAPI_VERSION > 7)
   exports.Set("object_freeze_seal", InitObjectFreezeSeal(env));
-  exports.Set("object_type_tag", InitObjectTypeTag(env));
+  exports.Set("type_taggable", InitTypeTaggable(env));
 #endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)

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

@@ -20,6 +20,7 @@
         'callbackInfo.cc',
         'date.cc',
         'binding.cc',
+        'buffer_no_external.cc',
         'buffer.cc',
         'callbackscope.cc',
         'dataview/dataview.cc',
@@ -47,7 +48,6 @@
         'object/has_property.cc',
         'object/object.cc',
         'object/object_freeze_seal.cc',
-        'object/object_type_tag.cc',
         'object/set_property.cc',
         'object/subscript_operator.cc',
         'promise.cc',
@@ -59,6 +59,7 @@
         'threadsafe_function/threadsafe_function_sum.cc',
         'threadsafe_function/threadsafe_function_unref.cc',
         'threadsafe_function/threadsafe_function.cc',
+        'type_taggable.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ctx.cc',
         'typed_threadsafe_function/typed_threadsafe_function_existing_tsfn.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ptr.cc',
@@ -80,6 +81,9 @@
         'binding-swallowexcept.cc',
         'error.cc',
       ],
+      'build_sources_type_check': [
+        'value_type_cast.cc'
+      ],
       'conditions': [
         ['disable_deprecated!="true"', {
           'build_sources': ['object/object_deprecated.cc']
@@ -116,6 +120,12 @@
       'sources': ['>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
+    {
+      'target_name': 'binding_type_check',
+      'includes': ['../noexcept.gypi'],
+      'sources': ['>@(build_sources_type_check)'],
+      'defines': ['NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS']
+    },
     {
       'target_name': 'binding_custom_namespace',
       'includes': ['../noexcept.gypi'],

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

@@ -1,30 +1,16 @@
+#include "buffer.h"
 #include "napi.h"
 
 using namespace Napi;
 
-namespace {
-
-const size_t testLength = 4;
+namespace test_buffer {
 uint16_t testData[testLength];
 int finalizeCount = 0;
+}  // namespace test_buffer
 
-template <typename T>
-void InitData(T* data, size_t length) {
-  for (size_t i = 0; i < length; i++) {
-    data[i] = static_cast<T>(i);
-  }
-}
-
-template <typename T>
-bool VerifyData(T* data, size_t length) {
-  for (size_t i = 0; i < length; i++) {
-    if (data[i] != static_cast<T>(i)) {
-      return false;
-    }
-  }
-  return true;
-}
+using namespace test_buffer;
 
+namespace {
 Value CreateBuffer(const CallbackInfo& info) {
   Buffer<uint16_t> buffer = Buffer<uint16_t>::New(info.Env(), testLength);
 
@@ -146,6 +132,8 @@ Value CreateBufferCopy(const CallbackInfo& info) {
   return buffer;
 }
 
+#include "buffer_new_or_copy-inl.h"
+
 void CheckBuffer(const CallbackInfo& info) {
   if (!info[0].IsBuffer()) {
     Error::New(info.Env(), "A buffer was expected.")
@@ -183,6 +171,12 @@ Object InitBuffer(Env env) {
       Function::New(env, CreateExternalBufferWithFinalize);
   exports["createExternalBufferWithFinalizeHint"] =
       Function::New(env, CreateExternalBufferWithFinalizeHint);
+  exports["createOrCopyExternalBuffer"] =
+      Function::New(env, CreateOrCopyExternalBuffer);
+  exports["createOrCopyExternalBufferWithFinalize"] =
+      Function::New(env, CreateOrCopyExternalBufferWithFinalize);
+  exports["createOrCopyExternalBufferWithFinalizeHint"] =
+      Function::New(env, CreateOrCopyExternalBufferWithFinalizeHint);
   exports["createBufferCopy"] = Function::New(env, CreateBufferCopy);
   exports["checkBuffer"] = Function::New(env, CheckBuffer);
   exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);

package/vendor/node-addon-api/test/buffer.h

@@ -0,0 +1,26 @@
+#include <cstdint>
+#include <cstdlib>
+
+namespace test_buffer {
+
+const size_t testLength = 4;
+extern uint16_t testData[testLength];
+extern int finalizeCount;
+
+template <typename T>
+void InitData(T* data, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    data[i] = static_cast<T>(i);
+  }
+}
+
+template <typename T>
+bool VerifyData(T* data, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    if (data[i] != static_cast<T>(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+}  // namespace test_buffer

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

@@ -62,6 +62,88 @@ function test (binding) {
     () => {
       global.gc();
     },
+    () => {
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer',
+    () => {
+      const test = binding.buffer.createOrCopyExternalBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer with finalizer',
+    () => {
+      const test = binding.buffer.createOrCopyExternalBufferWithFinalize();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+    },
+    () => {
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer with finalizer hint',
+    () => {
+      const test = binding.buffer.createOrCopyExternalBufferWithFinalizeHint();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+    },
+    () => {
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer when NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED defined',
+    () => {
+      const test = binding.bufferNoExternal.createOrCopyExternalBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer with finalizer when NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED defined',
+    () => {
+      const test = binding.bufferNoExternal.createOrCopyExternalBufferWithFinalize();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      // finalizer should have been called when the buffer was created.
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+    },
+    () => {
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+
+    'Create or Copy External Buffer with finalizer hint when NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED defined',
+    () => {
+      const test = binding.bufferNoExternal.createOrCopyExternalBufferWithFinalizeHint();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      // finalizer should have been called when the buffer was created.
+      assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+    () => {
+      global.gc();
+    },
     () => {
       assert.strictEqual(1, binding.buffer.getFinalizeCount());
     }

package/vendor/node-addon-api/test/buffer_new_or_copy-inl.h

@@ -0,0 +1,68 @@
+// Same tests on when NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED is defined or not
+// defined.
+
+Value CreateOrCopyExternalBuffer(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  InitData(testData, testLength);
+  Buffer<uint16_t> buffer =
+      Buffer<uint16_t>::NewOrCopy(info.Env(), testData, testLength);
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  VerifyData(buffer.Data(), testLength);
+  return buffer;
+}
+
+Value CreateOrCopyExternalBufferWithFinalize(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  uint16_t* data = new uint16_t[testLength];
+  InitData(data, testLength);
+
+  Buffer<uint16_t> buffer = Buffer<uint16_t>::NewOrCopy(
+      info.Env(), data, testLength, [](Env /*env*/, uint16_t* finalizeData) {
+        delete[] finalizeData;
+        finalizeCount++;
+      });
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  VerifyData(buffer.Data(), testLength);
+  return buffer;
+}
+
+Value CreateOrCopyExternalBufferWithFinalizeHint(const CallbackInfo& info) {
+  finalizeCount = 0;
+
+  uint16_t* data = new uint16_t[testLength];
+  InitData(data, testLength);
+
+  char* hint = nullptr;
+  Buffer<uint16_t> buffer = Buffer<uint16_t>::NewOrCopy(
+      info.Env(),
+      data,
+      testLength,
+      [](Env /*env*/, uint16_t* finalizeData, char* /*finalizeHint*/) {
+        delete[] finalizeData;
+        finalizeCount++;
+      },
+      hint);
+
+  if (buffer.Length() != testLength) {
+    Error::New(info.Env(), "Incorrect buffer length.")
+        .ThrowAsJavaScriptException();
+    return Value();
+  }
+
+  VerifyData(buffer.Data(), testLength);
+  return buffer;
+}

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

@@ -0,0 +1,24 @@
+#define NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+// Should compile without errors
+#include "buffer.h"
+#include "napi.h"
+
+using namespace Napi;
+using namespace test_buffer;
+
+namespace {
+#include "buffer_new_or_copy-inl.h"
+}
+
+Object InitBufferNoExternal(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createOrCopyExternalBuffer"] =
+      Function::New(env, CreateOrCopyExternalBuffer);
+  exports["createOrCopyExternalBufferWithFinalize"] =
+      Function::New(env, CreateOrCopyExternalBufferWithFinalize);
+  exports["createOrCopyExternalBufferWithFinalizeHint"] =
+      Function::New(env, CreateOrCopyExternalBufferWithFinalizeHint);
+
+  return exports;
+}