koffi 0.9.30 → 0.9.33

package/src/util.cc

@@ -20,6 +20,40 @@
 
 namespace RG {
 
+const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions)
+{
+    if (value.IsString()) {
+        std::string str = value.As<Napi::String>();
+
+        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+
+        if (!type) {
+            ThrowError<Napi::TypeError>(value.Env(), "Unknown type string '%1'", str.c_str());
+            return nullptr;
+        }
+
+        if (out_directions) {
+            *out_directions = 1;
+        }
+        return type;
+    } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
+        Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
+
+        const TypeInfo *raw = external.Data();
+        const TypeInfo *type = AlignDown(raw, 4);
+        RG_ASSERT(type);
+
+        if (out_directions) {
+            Size delta = (uint8_t *)raw - (uint8_t *)type;
+            *out_directions = 1 + (int)delta;
+        }
+        return type;
+    } else {
+        ThrowError<Napi::TypeError>(value.Env(), "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
+        return nullptr;
+    }
+}
+
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
     for (const TypeInfo &type: instance->types) {
@@ -327,7 +361,7 @@ static void DumpMemory(const char *type, Span<const uint8_t> bytes)
 
 void CallData::DumpDebug() const
 {
-    PrintLn(stderr, "%!..+---- %1 ----%!0", func->name);
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
 
     if (func->parameters.len) {
         PrintLn(stderr, "Parameters:");

package/src/util.hh

@@ -51,6 +51,8 @@ static inline T *AlignDown(T *ptr, Size align)
     return (T *)aligned;
 }
 
+const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions = nullptr);
+
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);
 

package/test/tests/misc.c

@@ -15,6 +15,7 @@
 #include <stdio.h>
 #include <inttypes.h>
 #include <string.h>
+#include <stdarg.h>
 
 #ifdef _WIN32
     #define EXPORT __declspec(dllexport)
@@ -34,6 +35,13 @@
     #define STDCALL
 #endif
 
+typedef struct Pack1 {
+    int a;
+} Pack1;
+typedef struct Pack2 {
+    int a;
+    int b;
+} Pack2;
 typedef struct Pack3 {
     int a;
     int b;
@@ -69,6 +77,47 @@ typedef struct PackedBFG {
 } PackedBFG;
 #pragma pack(pop)
 
+EXPORT void FillPack1(int a, Pack1 *p)
+{
+    p->a = a;
+}
+
+EXPORT Pack1 RetPack1(int a)
+{
+    Pack1 p;
+
+    p.a = a;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack1(int a, Pack1 *p)
+{
+    p->a += a;
+}
+
+EXPORT void FillPack2(int a, int b, Pack2 *p)
+{
+    p->a = a;
+    p->b = b;
+}
+
+EXPORT Pack2 RetPack2(int a, int b)
+{
+    Pack2 p;
+
+    p.a = a;
+    p.b = b;
+
+    return p;
+}
+
+EXPORT void FASTCALL AddPack2(int a, int b, Pack2 *p)
+{
+    p->a += a;
+    p->b += b;
+}
+
 EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 {
     p->a = a;
@@ -79,7 +128,7 @@ EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 EXPORT Pack3 RetPack3(int a, int b, int c)
 {
     Pack3 p;
-    
+
     p.a = a;
     p.b = b;
     p.c = c;
@@ -197,3 +246,15 @@ EXPORT const char *ReturnBigString(const char *str)
 
     return buf;
 }
+
+EXPORT const char *PrintFmt(const char *fmt, ...)
+{
+    static char buf[256];
+
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+
+    return buf;
+}

package/test/tests/misc.js

@@ -17,6 +17,13 @@ const koffi = require('../build/koffi.node');
 const assert = require('assert');
 const path = require('path');
 
+const Pack1 = koffi.struct('Pack1', {
+    a: 'int'
+});
+const Pack2 = koffi.struct('Pack2', {
+    a: 'int',
+    b: 'int'
+});
 const Pack3 = koffi.struct('Pack3', {
     a: 'int',
     b: 'int',
@@ -62,6 +69,12 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/../build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
+    const FillPack1 = lib.cdecl('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
+    const RetPack1 = lib.cdecl('RetPack1', Pack1, ['int']);
+    const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
+    const FillPack2 = lib.cdecl('FillPack2', 'void', ['int', 'int', koffi.out(koffi.pointer(Pack2))]);
+    const RetPack2 = lib.cdecl('RetPack2', Pack2, ['int', 'int']);
+    const AddPack2 = lib.fastcall('AddPack2', 'void', ['int', 'int', koffi.inout(koffi.pointer(Pack2))]);
     const FillPack3 = lib.cdecl('FillPack3', 'void', ['int', 'int', 'int', koffi.out(koffi.pointer(Pack3))]);
     const RetPack3 = lib.cdecl('RetPack3', Pack3, ['int', 'int', 'int']);
     const AddPack3 = lib.fastcall('AddPack3', 'void', ['int', 'int', 'int', koffi.inout(koffi.pointer(Pack3))]);
@@ -74,8 +87,37 @@ async function test() {
     const MakeBFG = lib.stdcall('MakeBFG', BFG, [koffi.out(koffi.pointer(BFG)), 'int', 'double', 'string']);
     const MakePackedBFG = lib.fastcall('MakePackedBFG', PackedBFG, ['int', 'double', koffi.out(koffi.pointer(PackedBFG)), 'string']);
     const ReturnBigString = lib.stdcall('ReturnBigString', 'string', ['string']);
+    const PrintFmt = lib.cdecl('PrintFmt', 'string', ['string', '...']);
+
+    // Simple tests with Pack1
+    {
+        let p = {};
+
+        FillPack1(777, p);
+        assert.deepEqual(p, { a: 777 });
+
+        let q = RetPack1(6);
+        assert.deepEqual(q, { a: 6 });
+
+        AddPack1(6, p);
+        assert.deepEqual(p, { a: 783 });
+    }
 
-    // Simple tests
+    // Simple tests with Pack2
+    {
+        let p = {};
+
+        FillPack2(123, 456, p);
+        assert.deepEqual(p, { a: 123, b: 456 });
+
+        let q = RetPack2(6, 9);
+        assert.deepEqual(q, { a: 6, b: 9 });
+
+        AddPack2(6, 9, p);
+        assert.deepEqual(p, { a: 129, b: 465 });
+    }
+
+    // Simple tests with Pack3
     {
         let p = {};
 
@@ -120,4 +162,10 @@ async function test() {
         let str = 'fooBAR!'.repeat(1024 * 1024);
         assert.equal(ReturnBigString(str), str);
     }
+
+    // Variadic
+    {
+        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
+        assert.equal(str, 'foo 200 1.5 BAR');
+    }
 }

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

@@ -1,5 +1,62 @@
 # node-addon-api Changelog
 
+## 2022-05-02 Version 5.0.0, @NickNaso
+
+### Notable changes:
+
+#### API
+- Marked methods of wrapper classes `const`.
+- Enabled wrapping `Napi` namespace with custom namespace.
+- Added an override to `Napi::Function::Call` to call it with a c-style array
+of `Napi::Value`'s.
+- Some other minor fixes.
+
+#### TEST
+
+- Improved the test framework. Added the possibility to run subsets of tests
+more easily.
+- Added test for `Napi::AsyncContext` class.
+- Fixed ramdom failure on test for `Napi::ThreadSafeFunction` e 
+`Napi::TypedThreadSafeFunction` class.
+- Fixed compilation problem on debian 8 system.
+- Added test for `Napi::Object::Set()` method.
+
+### Documentation
+- Added some clarifications for `Napi::ClassPropertyDescriptor`.
+- Added clarification about weak reference for `Napi::ObjectWrap`.
+- Some minor fixes all over the documentation.
+
+### TOOL
+
+- Fixed `eslint` configuration.
+- Fixed CI configuration for Windows.
+- Enabled pre-commit `ClangFormat` on Windows.
+
+### Commits
+
+* \[[`f32db917f3`](https://github.com/nodejs/node-addon-api/commit/f32db917f3)] - Add test coverage for async contexts (#1164) (Jack)
+* \[[`24455f88af`](https://github.com/nodejs/node-addon-api/commit/24455f88af)] - **src**: check for tsfn in conditional\_variable wait (Kevin Eady) [#1168](https://github.com/nodejs/node-addon-api/pull/1168)
+* \[[`40ed7ce409`](https://github.com/nodejs/node-addon-api/commit/40ed7ce409)] - **src**: fix regression introduced by #874 (Michael Dawson)
+* \[[`9bea434326`](https://github.com/nodejs/node-addon-api/commit/9bea434326)] - **doc**: added some comments to ClassPropertyDescriptor. (#1149) (Nicola Del Gobbo)
+* \[[`57c212e15f`](https://github.com/nodejs/node-addon-api/commit/57c212e15f)] - **buld**: Enable running pre-commit ClangFormat on Win (Vladimir Morozov)
+* \[[`8c46a9501a`](https://github.com/nodejs/node-addon-api/commit/8c46a9501a)] - **doc**: clarify ObjectWrap weak ref behavior (#1155) (Alba Mendez)
+* \[[`01274966d5`](https://github.com/nodejs/node-addon-api/commit/01274966d5)] - **build**: run Windows CI only on nondeprecated build configurations (#1152) (Darshan Sen)
+* \[[`b8449e17e0`](https://github.com/nodejs/node-addon-api/commit/b8449e17e0)] - **src**: mark methods of wrapper classes const (Nikolai Vavilov) [#874](https://github.com/nodejs/node-addon-api/pull/874)
+* \[[`5e2c1f24f8`](https://github.com/nodejs/node-addon-api/commit/5e2c1f24f8)] - **lint**: set sourceType to 'script' (#1141) (Anna Henningsen)
+* \[[`da8af20152`](https://github.com/nodejs/node-addon-api/commit/da8af20152)] - **doc**: mention Napi::Env arg for Finalization callback (#1139) (extremeheat)
+* \[[`5b51864a39`](https://github.com/nodejs/node-addon-api/commit/5b51864a39)] - **src**: enable wrapping Napi namespace with custom namespace (#1135) (Anna Henningsen)
+* \[[`c54aeef5fd`](https://github.com/nodejs/node-addon-api/commit/c54aeef5fd)] - Add Function::Call Napi::Value override (#1026) (rgerd)
+* \[[`e906b5a7ce`](https://github.com/nodejs/node-addon-api/commit/e906b5a7ce)] - **test**: fix compilation problem on debian 8 (NickNaso) [#1138](https://github.com/nodejs/node-addon-api/pull/1138)
+* \[[`5790c55784`](https://github.com/nodejs/node-addon-api/commit/5790c55784)] - **src**: do not use non-static class member for constant value (#1134) (Anna Henningsen)
+* \[[`b7659db945`](https://github.com/nodejs/node-addon-api/commit/b7659db945)] - Merge pull request #1130 from meixg/main (Jack)
+* \[[`a840d51d21`](https://github.com/nodejs/node-addon-api/commit/a840d51d21)] - Add test case for Object Set using uint32 as key (meixg)
+* \[[`2c88a7ec4c`](https://github.com/nodejs/node-addon-api/commit/2c88a7ec4c)] - Merge pull request #1132 from JckXia/test-wfl-run (Jack)
+* \[[`d3a5ed3869`](https://github.com/nodejs/node-addon-api/commit/d3a5ed3869)] - _**Revert**_ "window CI to running on 2019" (JckXia)
+* \[[`cee899ade5`](https://github.com/nodejs/node-addon-api/commit/cee899ade5)] - **src**: allow customization of ObjectWrap behavior (Aaron Meriwether) [#1125](https://github.com/nodejs/node-addon-api/pull/1125)
+* \[[`91879b4082`](https://github.com/nodejs/node-addon-api/commit/91879b4082)] - remove window-latest to debug (JckXia)
+* \[[`1593ef46ee`](https://github.com/nodejs/node-addon-api/commit/1593ef46ee)] - Testing CI run (JckXia)
+* \[[`744c8d2410`](https://github.com/nodejs/node-addon-api/commit/744c8d2410)] - **test**: enhance the test framework (Deepak Rajamohan)
+
 ## 2022-01-21 Version 4.3.0, @NickNaso
 
 ### Notable changes:

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

@@ -10,7 +10,7 @@ git branch -u origin/main main
 ```
 
 # **node-addon-api module**
-This module contains **header-only C++ wrapper classes** which simplify
+This module contains  **header-only C++ wrapper classes** which simplify
 the use of the C based [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
 provided by Node.js when using C++. It provides a C++ object model
 and exception handling semantics with low overhead.
@@ -70,7 +70,7 @@ and node-addon-api.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 4.3.0**
+## **Current version: 5.0.0**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 
@@ -83,7 +83,7 @@ This allows addons built with it to run with Node.js versions which support the
 **However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that
 every year there will be a new major which drops support for the Node.js LTS version which has gone out of service.
 
-The oldest Node.js version supported by the current version of node-addon-api is Node.js 12.x.
+The oldest Node.js version supported by the current version of node-addon-api is Node.js 14.x.
 
 ## Setup
   - [Installation and usage](doc/setup.md)

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

@@ -67,7 +67,7 @@ static Napi::ArrayBuffer Napi::ArrayBuffer::New(napi_env env,
 - `[in] externalData`: The pointer to the external data to wrap.
 - `[in] byteLength`: The length of the `externalData`, in bytes.
 - `[in] finalizeCallback`: A function to be called when the `Napi::ArrayBuffer` is
-  destroyed. It must implement `operator()`, accept a `void*` (which is the
+  destroyed. It must implement `operator()`, accept an Napi::Env, a `void*` (which is the
   `externalData` pointer), and return `void`.
 
 Returns a new `Napi::ArrayBuffer` instance.
@@ -94,7 +94,7 @@ static Napi::ArrayBuffer Napi::ArrayBuffer::New(napi_env env,
 - `[in] externalData`: The pointer to the external data to wrap.
 - `[in] byteLength`: The length of the `externalData`, in bytes.
 - `[in] finalizeCallback`: The function to be called when the `Napi::ArrayBuffer` is
-  destroyed. It must implement `operator()`, accept a `void*` (which is the
+  destroyed. It must implement `operator()`, accept an Napi::Env, a `void*` (which is the
   `externalData` pointer) and `Hint*`, and return `void`.
 - `[in] finalizeHint`: The hint to be passed as the second parameter of the
   finalize callback.

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

@@ -65,7 +65,7 @@ static Napi::Buffer<T> Napi::Buffer::New(napi_env env,
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
 - `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept a `T*` (which is the
+  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
   external data pointer), and return `void`.
 
 Returns a new `Napi::Buffer` object.
@@ -91,7 +91,7 @@ static Napi::Buffer<T> Napi::Buffer::New(napi_env env,
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
 - `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept a `T*` (which is the
+  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
   external data pointer) and `Hint*`, and return `void`.
 - `[in] finalizeHint`: The hint to be passed as the second parameter of the
   finalize callback.

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

@@ -1,10 +1,18 @@
 # Class property and descriptor
 
-Property descriptor for use with `Napi::ObjectWrap::DefineClass()`.
-This is different from the standalone `Napi::PropertyDescriptor` because it is
-specific to each `Napi::ObjectWrap<T>` subclass.
-This prevents using descriptors from a different class when defining a new class
-(preventing the callbacks from having incorrect `this` pointers).
+Property descriptor for use with `Napi::ObjectWrap<T>` and 
+`Napi::InstanceWrap<T>`. This is different from the standalone
+`Napi::PropertyDescriptor` because it is specific to each 
+`Napi::ObjectWrap<T>` and `Napi::InstanceWrap<T>` subclasses.
+This prevents using descriptors from a different class when defining a new
+class (preventing the callbacks from having incorrect `this` pointers).
+
+`Napi::ClassPropertyDescriptor` is a helper class created with
+`Napi::ObjectWrap<T>` and `Napi::InstanceWrap<T>`. For more reference about it
+see:
+
+- [InstanceWrap](./instance_wrap.md)
+- [ObjectWrap](./object_wrap.md)
 
 ## Example
 

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

@@ -57,7 +57,7 @@ Returns a `bool` indicating if an exception is pending in the environment.
 ### GetAndClearPendingException
 
 ```cpp
-Napi::Error Napi::Env::GetAndClearPendingException();
+Napi::Error Napi::Env::GetAndClearPendingException() const;
 ```
 
 Returns an `Napi::Error` object representing the environment's pending exception, if any.
@@ -65,7 +65,7 @@ Returns an `Napi::Error` object representing the environment's pending exception
 ### RunScript
 
 ```cpp
-Napi::Value Napi::Env::RunScript(____ script);
+Napi::Value Napi::Env::RunScript(____ script) const;
 ```
 - `[in] script`: A string containing JavaScript code to execute.
 
@@ -78,7 +78,7 @@ The `script` can be any of the following types:
 
 ### GetInstanceData
 ```cpp
-template <typename T> T* GetInstanceData();
+template <typename T> T* GetInstanceData() const;
 ```
 
 Returns the instance data that was previously associated with the environment,
@@ -89,7 +89,7 @@ or `nullptr` if none was associated.
 ```cpp
 template <typename T> using Finalizer = void (*)(Env, T*);
 template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
-void SetInstanceData(T* data);
+void SetInstanceData(T* data) const;
 ```
 
 - `[template] fini`: A function to call when the instance data is to be deleted.
@@ -112,7 +112,7 @@ template <typename DataType,
           typename HintType,
           FinalizerWithHint<DataType, HintType> fini =
             Env::DefaultFiniWithHint<DataType, HintType>>
-void SetInstanceData(DataType* data, HintType* hint);
+void SetInstanceData(DataType* data, HintType* hint) const;
 ```
 
 - `[template] fini`: A function to call when the instance data is to be deleted.

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

@@ -72,7 +72,7 @@ Creates a new `Napi::Object` value.
 ### Set()
 
 ```cpp
-bool Napi::Object::Set (____ key, ____ value);
+bool Napi::Object::Set (____ key, ____ value) const;
 ```
 - `[in] key`: The name for the property being assigned.
 - `[in] value`: The value being assigned to the property.
@@ -91,7 +91,7 @@ The `value` can be of any type that is accepted by [`Napi::Value::From`][].
 ### Delete()
 
 ```cpp
-bool Napi::Object::Delete(____ key);
+bool Napi::Object::Delete(____ key) const;
 ```
 - `[in] key`: The name of the property to delete.
 
@@ -143,7 +143,7 @@ Note: This is equivalent to the JavaScript instanceof operator.
 ### AddFinalizer()
 ```cpp
 template <typename Finalizer, typename T>
-inline void AddFinalizer(Finalizer finalizeCallback, T* data);
+inline void AddFinalizer(Finalizer finalizeCallback, T* data) const;
 ```
 
 - `[in] finalizeCallback`: The function to call when the object is garbage-collected.
@@ -161,7 +161,7 @@ where `data` is the pointer that was passed into the call to `AddFinalizer()`.
 template <typename Finalizer, typename T, typename Hint>
 inline void AddFinalizer(Finalizer finalizeCallback,
                          T* data,
-                         Hint* finalizeHint);
+                         Hint* finalizeHint) const;
 ```
 
 - `[in] data`: The data to associate with the object.
@@ -184,7 +184,7 @@ The properties whose key is a `Symbol` will not be included.
 
 ### HasOwnProperty()
 ```cpp
-bool Napi::Object::HasOwnProperty(____ key); const
+bool Napi::Object::HasOwnProperty(____ key) const;
 ```
 - `[in] key` The name of the property to check.
 
@@ -200,7 +200,7 @@ The key can be any of the following types:
 ### DefineProperty()
 
 ```cpp
-bool Napi::Object::DefineProperty (const Napi::PropertyDescriptor& property);
+bool Napi::Object::DefineProperty (const Napi::PropertyDescriptor& property) const;
 ```
 - `[in] property`: A [`Napi::PropertyDescriptor`](property_descriptor.md).
 
@@ -209,7 +209,7 @@ Define a property on the object.
 ### DefineProperties()
 
 ```cpp
-bool Napi::Object::DefineProperties (____ properties)
+bool Napi::Object::DefineProperties (____ properties) const;
 ```
 - `[in] properties`: A list of [`Napi::PropertyDescriptor`](property_descriptor.md). Can be one of the following types:
   - const std::initializer_list<Napi::PropertyDescriptor>&
@@ -220,7 +220,7 @@ Defines properties on the object.
 ### Freeze()
 
 ```cpp
-void Napi::Object::Freeze()
+void Napi::Object::Freeze() const;
 ```
 
 The `Napi::Object::Freeze()` method freezes an object. A frozen object can no
@@ -233,7 +233,7 @@ freezing an object also prevents its prototype from being changed.
 ### Seal()
 
 ```cpp
-void Napi::Object::Seal()
+void Napi::Object::Seal() const;
 ```
 
 The `Napi::Object::Seal()` method seals an object, preventing new properties
@@ -244,7 +244,7 @@ writable.
 ### operator\[\]()
 
 ```cpp
-Napi::PropertyLValue<std::string> Napi::Object::operator[] (const char* utf8name);
+Napi::PropertyLValue<std::string> Napi::Object::operator[] (const char* utf8name) const;
 ```
 - `[in] utf8name`: UTF-8 encoded null-terminated property name.
 
@@ -252,7 +252,7 @@ Returns a [`Napi::Object::PropertyLValue`](propertylvalue.md) as the named
 property or sets the named property.
 
 ```cpp
-Napi::PropertyLValue<std::string> Napi::Object::operator[] (const std::string& utf8name);
+Napi::PropertyLValue<std::string> Napi::Object::operator[] (const std::string& utf8name) const;
 ```
 - `[in] utf8name`: UTF-8 encoded property name.
 
@@ -260,34 +260,13 @@ Returns a [`Napi::Object::PropertyLValue`](propertylvalue.md) as the named
 property or sets the named property.
 
 ```cpp
-Napi::PropertyLValue<uint32_t> Napi::Object::operator[] (uint32_t index);
+Napi::PropertyLValue<uint32_t> Napi::Object::operator[] (uint32_t index) const;
 ```
 - `[in] index`: Element index.
 
 Returns a [`Napi::Object::PropertyLValue`](propertylvalue.md) or sets an
 indexed property or array element.
 
-```cpp
-Napi::Value Napi::Object::operator[] (const char* utf8name) const;
-```
-- `[in] utf8name`: UTF-8 encoded null-terminated property name.
-
-Returns the named property as a [`Napi::Value`](value.md).
-
-```cpp
-Napi::Value Napi::Object::operator[] (const std::string& utf8name) const;
-```
-- `[in] utf8name`: UTF-8 encoded property name.
-
-Returns the named property as a [`Napi::Value`](value.md).
-
-```cpp
-Napi::Value Napi::Object::operator[] (uint32_t index) const;
-```
-- `[in] index`: Element index.
-
-Returns an indexed property or array element as a [`Napi::Value`](value.md).
-
 ### begin()
 
 ```cpp

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

@@ -103,7 +103,7 @@ The `value` can be any of the following types:
 ### Get
 
 ```cpp
-Napi::Value Napi::ObjectReference::Get(___ key);
+Napi::Value Napi::ObjectReference::Get(___ key) const;
 ```
 
 * `[in] key`: The name of the property to return the value for.

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

@@ -16,6 +16,10 @@ be directly invoked from JavaScript. The **wrap** word refers to a way of
 grouping methods and state of the class because it will be necessary write
 custom code to bridge each of your C++ class methods.
 
+**Caution:** When the JavaScript object is garbage collected, the call to the
+C++ destructor may be deferred until a later time. Within that period,
+`Value()` will return an empty value.
+
 ## Example
 
 ```cpp
@@ -212,6 +216,29 @@ property of the `Napi::CallbackInfo`.
 
 Returns a `Napi::Function` representing the constructor function for the class.
 
+### OnCalledAsFunction
+
+Provides an opportunity to customize the behavior when a `Napi::ObjectWrap<T>`
+class is called from JavaScript as a function (without the **new** operator).
+
+The default behavior in this scenario is to throw a `Napi::TypeError` with the
+message `Class constructors cannot be invoked without 'new'`.  Define this
+public method on your derived class to override that behavior.
+
+For example, you could internally re-call the JavaScript contstructor _with_
+the **new** operator (via
+`Napi::Function::New(const std::vector<napi_value> &args)`), and return the
+resulting object.  Or you might do something else entirely, such as the way
+[`Date()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#constructor)
+produces a string when called as a function.
+
+```cpp
+static Napi::Value OnCalledAsFunction(const Napi::CallbackInfo& callbackInfo);
+```
+
+- `[in] callbackInfo`: The object representing the components of the JavaScript
+request being made.
+
 ### Finalize
 
 Provides an opportunity to run cleanup code that requires access to the

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

@@ -69,7 +69,7 @@ Returns the value held by the `Napi::Reference`.
 ### Ref
 
 ```cpp
-uint32_t Napi::Reference::Ref();
+uint32_t Napi::Reference::Ref() const;
 ```
 
 Increments the reference count for the `Napi::Reference` and returns the resulting reference count. Throws an error if the increment fails.
@@ -77,7 +77,7 @@ Increments the reference count for the `Napi::Reference` and returns the resulti
 ### Unref
 
 ```cpp
-uint32_t Napi::Reference::Unref();
+uint32_t Napi::Reference::Unref() const;
 ```
 
 Decrements the reference count for the `Napi::Reference` and returns the resulting reference count. Throws an error if the decrement fails.

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

@@ -83,7 +83,7 @@ Add a thread to this thread-safe function object, indicating that a new thread
 will start making use of the thread-safe function.
 
 ```cpp
-napi_status Napi::ThreadSafeFunction::Acquire()
+napi_status Napi::ThreadSafeFunction::Acquire() const
 ```
 
 Returns one of:
@@ -100,7 +100,7 @@ thread-safe function. Using any thread-safe APIs after having called this API
 has undefined results in the current thread, as it may have been destroyed.
 
 ```cpp
-napi_status Napi::ThreadSafeFunction::Release()
+napi_status Napi::ThreadSafeFunction::Release() const
 ```
 
 Returns one of:
@@ -122,7 +122,7 @@ make no further use of the thread-safe function because it is no longer
 guaranteed to be allocated.
 
 ```cpp
-napi_status Napi::ThreadSafeFunction::Abort()
+napi_status Napi::ThreadSafeFunction::Abort() const
 ```
 
 Returns one of:

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

@@ -124,7 +124,7 @@ has undefined results in the current thread, as the thread-safe function may
 have been destroyed.
 
 ```cpp
-napi_status Napi::TypedThreadSafeFunction<ContextType, DataType, Callback>::Release()
+napi_status Napi::TypedThreadSafeFunction<ContextType, DataType, Callback>::Release() const
 ```
 
 Returns one of:
@@ -146,7 +146,7 @@ function call a thread must make no further use of the thread-safe function
 because it is no longer guaranteed to be allocated.
 
 ```cpp
-napi_status Napi::TypedThreadSafeFunction<ContextType, DataType, Callback>::Abort()
+napi_status Napi::TypedThreadSafeFunction<ContextType, DataType, Callback>::Abort() const
 ```
 
 Returns one of: