koffi 2.16.0-beta.2 → 2.16.1

package/vendor/node-addon-api/benchmark/property_descriptor.cc

@@ -1,84 +0,0 @@
-#include "napi.h"
-
-static napi_value Getter_Core(napi_env env, napi_callback_info info) {
-  (void)info;
-  napi_value result;
-  napi_status status = napi_create_uint32(env, 42, &result);
-  NAPI_THROW_IF_FAILED(env, status, nullptr);
-  return result;
-}
-
-static napi_value Setter_Core(napi_env env, napi_callback_info info) {
-  size_t argc = 1;
-  napi_value argv;
-  napi_status status =
-      napi_get_cb_info(env, info, &argc, &argv, nullptr, nullptr);
-  NAPI_THROW_IF_FAILED(env, status, nullptr);
-  (void)argv;
-  return nullptr;
-}
-
-static Napi::Value Getter(const Napi::CallbackInfo& info) {
-  return Napi::Number::New(info.Env(), 42);
-}
-
-static void Setter(const Napi::CallbackInfo& info) {
-  (void)info[0];
-}
-
-#if NAPI_VERSION > 5
-class PropDescBenchmark : public Napi::Addon<PropDescBenchmark> {
- public:
-  PropDescBenchmark(Napi::Env, Napi::Object exports) {
-    DefineAddon(exports,
-                {
-                    InstanceAccessor("addon",
-                                     &PropDescBenchmark::Getter,
-                                     &PropDescBenchmark::Setter,
-                                     napi_enumerable),
-                    InstanceAccessor<&PropDescBenchmark::Getter,
-                                     &PropDescBenchmark::Setter>(
-                        "addon_templated", napi_enumerable),
-                });
-  }
-
- private:
-  Napi::Value Getter(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  void Setter(const Napi::CallbackInfo& info, const Napi::Value& val) {
-    (void)info[0];
-    (void)val;
-  }
-};
-#endif  // NAPI_VERSION > 5
-
-static Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  napi_status status;
-  napi_property_descriptor core_prop = {"core",
-                                        nullptr,
-                                        nullptr,
-                                        Getter_Core,
-                                        Setter_Core,
-                                        nullptr,
-                                        napi_enumerable,
-                                        nullptr};
-
-  status = napi_define_properties(env, exports, 1, &core_prop);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  exports.DefineProperty(Napi::PropertyDescriptor::Accessor(
-      env, exports, "cplusplus", Getter, Setter, napi_enumerable));
-
-  exports.DefineProperty(Napi::PropertyDescriptor::Accessor<Getter, Setter>(
-      "templated", napi_enumerable));
-
-#if NAPI_VERSION > 5
-  PropDescBenchmark::Init(env, exports);
-#endif  // NAPI_VERSION > 5
-
-  return exports;
-}
-
-NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

package/vendor/node-addon-api/benchmark/property_descriptor.js

@@ -1,38 +0,0 @@
-const path = require('path');
-const Benchmark = require('benchmark');
-const addonName = path.basename(__filename, '.js');
-
-[addonName, addonName + '_noexcept']
-  .forEach((addonName) => {
-    const rootAddon = require('bindings')({
-      bindings: addonName,
-      module_root: __dirname
-    });
-    delete rootAddon.path;
-    const getters = new Benchmark.Suite();
-    const setters = new Benchmark.Suite();
-    const maxNameLength = Object.keys(rootAddon)
-      .reduce((soFar, value) => Math.max(soFar, value.length), 0);
-
-    console.log(`\n${addonName}: `);
-
-    Object.keys(rootAddon).forEach((key) => {
-      getters.add(`${key} getter`.padStart(maxNameLength + 7), () => {
-        // eslint-disable-next-line no-unused-vars
-        const x = rootAddon[key];
-      });
-      setters.add(`${key} setter`.padStart(maxNameLength + 7), () => {
-        rootAddon[key] = 5;
-      });
-    });
-
-    getters
-      .on('cycle', (event) => console.log(String(event.target)))
-      .run();
-
-    console.log('');
-
-    setters
-      .on('cycle', (event) => console.log(String(event.target)))
-      .run();
-  });

package/vendor/node-addon-api/common.gypi

@@ -1,21 +0,0 @@
-{
-  'variables': {
-    'NAPI_VERSION%': "<!(node -p \"process.env.NAPI_VERSION || process.versions.napi\")",
-    'disable_deprecated': "<!(node -p \"process.env['npm_config_disable_deprecated']\")"
-  },
-  'conditions': [
-    ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
-    ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL'] } ],
-    ['disable_deprecated=="true"', {
-      'defines': ['NODE_ADDON_API_DISABLE_DEPRECATED']
-    }],
-    ['OS=="mac"', {
-      'cflags+': ['-fvisibility=hidden'],
-      'xcode_settings': {
-        'OTHER_CFLAGS': ['-fvisibility=hidden']
-      }
-    }]
-  ],
-  'cflags': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ],
-  'cflags_cc': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ]
-}

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

@@ -1,145 +0,0 @@
-# node-addon-api Documents
-
-* [Setup](#setup)
-* [API Documentation](#api)
-* [Examples](#examples)
-* [ABI Stability Guideline](#abi-stability-guideline)
-* [More resource and info about native Addons](#resources)
-
-Node-API is an ABI stable C interface provided by Node.js for building native
-addons. It is independent of the underlying JavaScript runtime (e.g. V8 or ChakraCore)
-and is maintained as part of Node.js itself. It is intended to insulate
-native addons from changes in the underlying JavaScript engine and allow
-modules compiled for one version to run on later versions of Node.js without
-recompilation.
-
-The `node-addon-api` module, which is not part of Node.js, preserves the benefits
-of the Node-API as it consists only of inline code that depends only on the stable API
-provided by Node-API. As such, modules built against one version of Node.js
-using node-addon-api should run without having to be rebuilt with newer versions
-of Node.js.
-
-## Setup
-  - [Installation and usage](setup.md)
-  - [node-gyp](node-gyp.md)
-  - [cmake-js](cmake-js.md)
-  - [Conversion tool](conversion-tool.md)
-  - [Checker tool](checker-tool.md)
-  - [Generator](generator.md)
-  - [Prebuild tools](prebuild_tools.md)
-
-<a name="api"></a>
-
-## API Documentation
-
-The following is the documentation for node-addon-api.
-
- - [Full Class Hierarchy](hierarchy.md)
- - [Addon Structure](addon.md)
- - Data Types:
-    - [BasicEnv](basic_env.md)
-    - [Env](env.md)
-    - [CallbackInfo](callbackinfo.md)
-    - [Reference](reference.md)
-    - [Value](value.md)
-        - [Name](name.md)
-            - [Symbol](symbol.md)
-            - [String](string.md)
-        - [Number](number.md)
-        - [Date](date.md)
-        - [BigInt](bigint.md)
-        - [Boolean](boolean.md)
-        - [External](external.md)
-        - [Object](object.md)
-            - [Array](array.md)
-            - [ObjectReference](object_reference.md)
-    - [PropertyDescriptor](property_descriptor.md)
-    - [Function](function.md)
-        - [FunctionReference](function_reference.md)
-    - [ObjectWrap](object_wrap.md)
-        - [ClassPropertyDescriptor](class_property_descriptor.md)
-    - [Buffer](buffer.md)
-    - [ArrayBuffer](array_buffer.md)
-    - [TypedArray](typed_array.md)
-      - [TypedArrayOf](typed_array_of.md)
-    - [DataView](dataview.md)
- - [Error Handling](error_handling.md)
-    - [Error](error.md)
-      - [TypeError](type_error.md)
-      - [RangeError](range_error.md)
-      - [SyntaxError](syntax_error.md)
- - [Object Lifetime Management](object_lifetime_management.md)
-    - [HandleScope](handle_scope.md)
-    - [EscapableHandleScope](escapable_handle_scope.md)
-    - [Finalization](finalization.md)
- - [Memory Management](memory_management.md)
- - [Async Operations](async_operations.md)
-    - [AsyncWorker](async_worker.md)
-    - [AsyncContext](async_context.md)
-    - [AsyncWorker Variants](async_worker_variants.md)
- - [Thread-safe Functions](threadsafe.md)
-    - [ThreadSafeFunction](threadsafe_function.md)
-    - [TypedThreadSafeFunction](typed_threadsafe_function.md)
- - [Promises](promises.md)
- - [Version management](version_management.md)
-
-<a name="examples"></a>
-
-## Examples
-
-Are you new to **node-addon-api**? Take a look at our **[examples](https://github.com/nodejs/node-addon-examples)**
-
-- [Hello World](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/1_hello_world)
-- [Pass arguments to a function](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/2_function_arguments/node-addon-api)
-- [Callbacks](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/3_callbacks/node-addon-api)
-- [Object factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/4_object_factory/node-addon-api)
-- [Function factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/5_function_factory/node-addon-api)
-- [Wrapping C++ Object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/6_object_wrap/node-addon-api)
-- [Factory of wrapped object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/7_factory_wrap/node-addon-api)
-- [Passing wrapped object around](https://github.com/nodejs/node-addon-examples/tree/main/src/2-js-to-native-conversion/8_passing_wrapped/node-addon-api)
-
-<a name="abi-stability-guideline"></a>
-
-## ABI Stability Guideline
-
-It is important to remember that *other* Node.js interfaces such as
-`libuv` (included in a project via `#include <uv.h>`) are not ABI-stable across
-Node.js major versions. Thus, an addon must use Node-API and/or `node-addon-api`
-exclusively and build against a version of Node.js that includes an
-implementation of Node-API (meaning an active LTS version of Node.js) in
-order to benefit from ABI stability across Node.js major versions. Node.js
-provides an [ABI stability guide][] containing a detailed explanation of ABI
-stability in general, and the Node-API ABI stability guarantee in particular.
-
-<a name="resources"></a>
-
-## More resource and info about native Addons
-
-There are three options for implementing addons: Node-API, nan, or direct
-use of internal V8, libuv, and Node.js libraries. Unless there is a need for
-direct access to functionality that is not exposed by Node-API as outlined
-in [C/C++ addons](https://nodejs.org/dist/latest/docs/api/addons.html)
-in Node.js core, use Node-API. Refer to
-[C/C++ addons with Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
-for more information on Node-API.
-
-- [C++ Addons](https://nodejs.org/dist/latest/docs/api/addons.html)
-- [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
-- [Node-API - Next Generation Node API for Native Modules](https://youtu.be/-Oniup60Afs)
-- [How We Migrated Realm JavaScript From NAN to Node-API](https://developer.mongodb.com/article/realm-javascript-nan-to-n-api)
-
-As node-addon-api's core mission is to expose the plain C Node-API as C++
-wrappers, tools that facilitate n-api/node-addon-api providing more
-convenient patterns for developing a Node.js add-on with n-api/node-addon-api
-can be published to NPM as standalone packages. It is also recommended to tag
-such packages with `node-addon-api` to provide more visibility to the community.
-
-Quick links to NPM searches: [keywords:node-addon-api](https://www.npmjs.com/search?q=keywords%3Anode-addon-api).
-
-<a name="other-bindings"></a>
-
-## Other bindings
-
-- [napi-rs](https://napi.rs) - (`Rust`)
-
-[ABI stability guide]: https://nodejs.org/en/docs/guides/abi-stability/

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

@@ -1,163 +0,0 @@
-# Add-on Structure
-
-Class `Napi::Addon<T>` inherits from class [`Napi::InstanceWrap<T>`][].
-
-Creating add-ons that work correctly when loaded multiple times from the same
-source package into multiple Node.js threads and/or multiple times into the same
-Node.js thread requires that all global data they hold be associated with the
-environment in which they run. It is not safe to store global data in static
-variables because doing so does not take into account the fact that an add-on
-may be loaded into multiple threads nor that an add-on may be loaded multiple
-times into a single thread.
-
-The `Napi::Addon<T>` class can be used to define an entire add-on. Instances of
-`Napi::Addon<T>` subclasses become instances of the add-on, stored safely by
-Node.js on its various threads and into its various contexts. Thus, any data
-stored in the instance variables of a `Napi::Addon<T>` subclass instance are
-stored safely by Node.js. Functions exposed to JavaScript using
-`Napi::Addon<T>::InstanceMethod` and/or `Napi::Addon<T>::DefineAddon` are
-instance methods of the `Napi::Addon` subclass and thus have access to data
-stored inside the instance.
-
-`Napi::Addon<T>::DefineProperties` may be used to attach `Napi::Addon<T>`
-subclass instance methods to objects other than the one that will be returned to
-Node.js as the add-on instance.
-
-The `Napi::Addon<T>` class can be used together with the `NODE_API_ADDON()` and
-`NODE_API_NAMED_ADDON()` macros to define add-ons.
-
-## Example
-
-```cpp
-#include <napi.h>
-
-class ExampleAddon : public Napi::Addon<ExampleAddon> {
- public:
-  ExampleAddon(Napi::Env env, Napi::Object exports) {
-    // In the constructor we declare the functions the add-on makes available
-    // to JavaScript.
-    DefineAddon(exports, {
-      InstanceMethod("increment", &ExampleAddon::Increment),
-
-      // We can also attach plain objects to `exports`, and instance methods as
-      // properties of those sub-objects.
-      InstanceValue("subObject", DefineProperties(Napi::Object::New(env), {
-        InstanceMethod("decrement", &ExampleAddon::Decrement)
-      }), napi_enumerable)
-    });
-  }
- private:
-
-  // This method has access to the data stored in the environment because it is
-  // an instance method of `ExampleAddon` and because it was listed among the
-  // property descriptors passed to `DefineAddon()` in the constructor.
-  Napi::Value Increment(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), ++value);
-  }
-
-  // This method has access to the data stored in the environment because it is
-  // an instance method of `ExampleAddon` and because it was exposed to
-  // JavaScript by calling `DefineProperties()` with the object onto which it is
-  // attached.
-  Napi::Value Decrement(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), --value);
-  }
-
-  // Data stored in these variables is unique to each instance of the add-on.
-  uint32_t value = 42;
-};
-
-// The macro announces that instances of the class `ExampleAddon` will be
-// created for each instance of the add-on that must be loaded into Node.js.
-NODE_API_ADDON(ExampleAddon)
-```
-
-The above code can be used from JavaScript as follows:
-
-```js
-'use strict'
-
-const exampleAddon = require('bindings')('example_addon');
-console.log(exampleAddon.increment()); // prints 43
-console.log(exampleAddon.increment()); // prints 44
-console.log(exampleAddon.subObject.decrement()); // prints 43
-```
-
-When Node.js loads an instance of the add-on, a new instance of the class is
-created. Its constructor receives the environment `Napi::Env env` and the
-exports object `Napi::Object exports`. It can then use the method `DefineAddon`
-to either attach methods, accessors, and/or values to the `exports` object or to
-create its own `exports` object and attach methods, accessors, and/or values to
-it.
-
-**Note:** `Napi::Addon<T>` uses `Napi::Env::SetInstanceData()` internally. This
-means that the add-on should only use `Napi::Env::GetInstanceData` explicitly to
-retrieve the instance of the `Napi::Addon<T>` class. Variables whose scope would
-otherwise be global should be stored as instance variables in the
-`Napi::Addon<T>` class.
-
-Functions created with `Napi::Function::New()`, accessors created with
-`PropertyDescriptor::Accessor()`, and values can also be attached. If their
-implementation requires the `ExampleAddon` instance, it can be retrieved from
-the `Napi::Env env` with `GetInstanceData()`:
-
-```cpp
-void ExampleBinding(const Napi::CallbackInfo& info) {
-  ExampleAddon* addon = info.Env().GetInstanceData<ExampleAddon>();
-}
-```
-
-## Methods
-
-### Constructor
-
-Creates a new instance of the add-on.
-
-```cpp
-Napi::Addon(Napi::Env env, Napi::Object exports);
-```
-
-- `[in] env`: The environment into which the add-on is being loaded.
-- `[in] exports`: The exports object received from JavaScript.
-
-Typically, the constructor calls `DefineAddon()` to attach methods, accessors,
-and/or values to `exports`. The constructor may also create a new object and
-pass it to `DefineAddon()` as its first parameter if it wishes to replace the
-`exports` object as provided by Node.js.
-
-### DefineAddon
-
-Defines an add-on instance with functions, accessors, and/or values.
-
-```cpp
-template <typename T>
-void Napi::Addon<T>::DefineAddon(Napi::Object exports,
-                   const std::initializer_list<PropertyDescriptor>& properties);
-```
-
-* `[in] exports`: The object to return to Node.js as an instance of the add-on.
-* `[in] properties`: Initializer list of add-on property descriptors of the
-methods, property accessors, and values that define the add-on. They will be
-set on `exports`.
-See: [`Class property and descriptor`](class_property_descriptor.md).
-
-### DefineProperties
-
-Defines function, accessor, and/or value properties on an object using add-on
-instance methods.
-
-```cpp
-template <typename T>
-Napi::Object
-Napi::Addon<T>::DefineProperties(Napi::Object object,
-                   const std::initializer_list<PropertyDescriptor>& properties);
-```
-
-* `[in] object`: The object that will receive the new properties.
-* `[in] properties`: Initializer list of property descriptors of the methods,
-property accessors, and values to attach to `object`.
-See: [`Class property and descriptor`](class_property_descriptor.md).
-
-Returns `object`.
-
-[`Napi::InstanceWrap<T>`]: ./instance_wrap.md

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

@@ -1,81 +0,0 @@
-# Array
-
-Class [`Napi::Array`][] inherits from class [`Napi::Object`][].
-
-Arrays are native representations of JavaScript Arrays. `Napi::Array` is a wrapper
-around `napi_value` representing a JavaScript Array.
-
-[`Napi::TypedArray`][] and [`Napi::ArrayBuffer`][] correspond to JavaScript data
-types such as [`Napi::Int32Array`][] and [`Napi::ArrayBuffer`][], respectively,
-that can be used for transferring large amounts of data from JavaScript to the
-native side. An example illustrating the use of a JavaScript-provided
-`ArrayBuffer` in native code is available [here](https://github.com/nodejs/node-addon-examples/tree/main/src/2-js-to-native-conversion/array_buffer_to_native/node-addon-api).
-
-## Constructor
-```cpp
-Napi::Array::Array();
-```
-
-Returns an empty array.
-
-If an error occurs, a `Napi::Error` will be thrown. If C++ exceptions are not
-being used, callers should check the result of `Env::IsExceptionPending` before
-attempting to use the returned value.
-
-```cpp
-Napi::Array::Array(napi_env env, napi_value value);
-```
-- `[in] env` - The environment in which to create the array.
-- `[in] value` - The primitive to wrap.
-
-Returns a `Napi::Array` wrapping a `napi_value`.
-
-If an error occurs, a `Napi::Error` will get thrown. If C++ exceptions are not
-being used, callers should check the result of `Env::IsExceptionPending` before
-attempting to use the returned value.
-
-## Methods
-
-### New
-```cpp
-static Napi::Array Napi::Array::New(napi_env env);
-```
-- `[in] env` - The environment in which to create the array.
-
-Returns a new `Napi::Array`.
-
-If an error occurs, a `Napi::Error` will get thrown. If C++ exceptions are not
-being used, callers should check the result of `Env::IsExceptionPending` before
-attempting to use the returned value.
-
-### New
-
-```cpp
-static Napi::Array Napi::Array::New(napi_env env, size_t length);
-```
-- `[in] env` - The environment in which to create the array.
-- `[in] length` - The length of the array.
-
-Returns a new `Napi::Array` with the given length.
-
-If an error occurs, a `Napi::Error` will get thrown. If C++ exceptions are not
-being used, callers should check the result of `Env::IsExceptionPending` before
-attempting to use the returned value.
-
-### Length
-```cpp
-uint32_t Napi::Array::Length() const;
-```
-
-Returns the length of the array.
-
-Note:
-This can execute JavaScript code implicitly according to JavaScript semantics.
-If an error occurs, a `Napi::Error` will get thrown. If C++ exceptions are not
-being used, callers should check the result of `Env::IsExceptionPending` before
-attempting to use the returned value.
-
-[`Napi::ArrayBuffer`]: ./array_buffer.md
-[`Napi::Int32Array`]: ./typed_array_of.md
-[`Napi::Object`]: ./object.md
-[`Napi::TypedArray`]: ./typed_array.md