koffi 3.0.2 → 3.1.1

package/src/koffi/src/util.cc

@@ -40,7 +40,8 @@ UnionValue::UnionValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
 
-    instance = env.GetInstanceData<InstanceData>();
+    K_ASSERT(type->instance);
+    instance = type->instance;
 
     if (info.Length() >= 1) {
         if (!info[0].IsExternal()) [[unlikely]] {
@@ -57,7 +58,7 @@ UnionValue::UnionValue(const Napi::CallbackInfo &info)
 
 void UnionValue::Finalize(Napi::BasicEnv env)
 {
-    DeleteReferenceSafe(env, *this);
+    node_api_delete_reference(env, *this);
     SuppressDestruct();
 }
 
@@ -137,18 +138,6 @@ bool CheckValueTag(napi_env env, napi_value value, const void *marker)
     return match;
 }
 
-void DeleteReferenceSafe(napi_env env, napi_ref ref)
-{
-    if (node_api_post_finalizer) {
-        node_api_post_finalizer(env, [](napi_env env, void *data, void *) {
-            napi_ref ref = (napi_ref)data;
-            napi_delete_reference(env, ref);
-        }, (void *)ref, nullptr);
-    } else {
-        napi_delete_reference(env, ref);
-    }
-}
-
 int GetTypedArrayType(const TypeInfo *type)
 {
     switch (type->primitive) {
@@ -167,7 +156,7 @@ int GetTypedArrayType(const TypeInfo *type)
     K_UNREACHABLE();
 }
 
-Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
+static FORCE_INLINE napi_value NewStringUTF32(Napi::Env env, const char32_t *ptr, Size len)
 {
     static const char16_t ReplacementChar = 0xFFFD;
 
@@ -193,8 +182,30 @@ Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
         }
     }
 
-    Napi::String str = Napi::String::New(env, buf.ptr, buf.len);
-    return str;
+    return NewString(env, buf.ptr, buf.len);
+}
+
+napi_value NewString(Napi::Env env, const char32_t *ptr, Size len)
+{
+    if (ptr) {
+        return NewStringUTF32(env, ptr, len);
+    } else {
+        napi_value value;
+        NAPI_OK(napi_get_null(env, &value));
+        return value;
+    }
+}
+
+napi_value NewString(Napi::Env env, const char32_t *ptr)
+{
+    if (ptr) {
+        Size len =  NullTerminatedLength(ptr);
+        return NewStringUTF32(env, ptr, len);
+    } else {
+        napi_value value;
+        NAPI_OK(napi_get_null(env, &value));
+        return value;
+    }
 }
 
 static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &by)
@@ -379,25 +390,25 @@ static FORCE_INLINE void DecodeObject(InstanceData *instance, const uint8_t *ori
             case PrimitiveKind::String: {
                 const char *str;
                 memcpy(&str, src, K_SIZE(void *));
-                set(i, member, str ? Napi::String::New(env, str) : env.Null());
+                set(i, member, NewString(env, str));
 
                 if (member.type->dispose) {
-                    member.type->dispose(env, member.type, str);
+                    member.type->dispose(instance, member.type, str);
                 }
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
                 memcpy(&str16, src, K_SIZE(void *));
-                set(i, member, str16 ? Napi::String::New(env, str16) : env.Null());
+                set(i, member, NewString(env, str16));
 
                 if (member.type->dispose) {
-                    member.type->dispose(env, member.type, str16);
+                    member.type->dispose(instance, member.type, str16);
                 }
             } break;
             case PrimitiveKind::String32: {
                 const char32_t *str32;
                 memcpy(&str32, src, K_SIZE(void *));
-                set(i, member, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+                set(i, member, NewString(env, str32));
             } break;
             case PrimitiveKind::Pointer: {
                 void *ptr2;
@@ -410,23 +421,23 @@ static FORCE_INLINE void DecodeObject(InstanceData *instance, const uint8_t *ori
                     napi_value value = DecodeArray(instance, (const uint8_t *)ptr2, member.type, len);
                     set(i, member, value);
                 } else {
-                    napi_value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                    napi_value p = WrapPointer(env, member.type->ref.type, ptr2);
                     set(i, member, p);
                 }
 
                 if (member.type->dispose) {
-                    member.type->dispose(env, member.type, ptr2);
+                    member.type->dispose(instance, member.type, ptr2);
                 }
             } break;
             case PrimitiveKind::Callback: {
                 void *ptr2;
                 memcpy(&ptr2, src, K_SIZE(void *));
 
-                napi_value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                napi_value p = WrapPointer(env, member.type->ref.type, ptr2);
                 set(i, member, p);
 
                 if (member.type->dispose) {
-                    member.type->dispose(env, member.type, ptr2);
+                    member.type->dispose(instance, member.type, ptr2);
                 }
             } break;
             case PrimitiveKind::Record:
@@ -454,12 +465,12 @@ static FORCE_INLINE void DecodeObject(InstanceData *instance, const uint8_t *ori
             case PrimitiveKind::Float32: {
                 float f;
                 memcpy(&f, src, 4);
-                set(i, member, Napi::Number::New(env, (double)f));
+                set(i, member, NewFloat(env, f));
             } break;
             case PrimitiveKind::Float64: {
                 double d;
                 memcpy(&d, src, 8);
-                set(i, member, Napi::Number::New(env, d));
+                set(i, member, NewFloat(env, d));
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -473,8 +484,16 @@ napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const Typ
 
     // We can't decode unions because we don't know which member is valid
     if (type->primitive == PrimitiveKind::Union) {
+        Napi::Function construct;
+        {
+            napi_value value;
+            NAPI_OK(napi_get_reference_value(env, type->construct, &value));
+
+            construct = Napi::Function(env, value);
+        }
+
         Napi::External<void> external = Napi::External<void>::New(env, (void *)origin);
-        Napi::Object wrapper = type->construct.New({ external }).As<Napi::Object>();
+        Napi::Object wrapper = construct.New({ external }).As<Napi::Object>();
         SetValueTag(env, wrapper, &UnionValueMarker);
 
         return wrapper;
@@ -507,14 +526,14 @@ void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin,
     Napi::Env env = instance->env;
 
     if (node_api_create_property_key_utf8) {
-        DecodeObject(instance, origin, type, [&](Size i, const RecordMember &member, napi_value value) {
+        DecodeObject(instance, origin, type, [&](Size, const RecordMember &member, napi_value value) {
             napi_value key = nullptr;
             napi_get_reference_value(env, member.key, &key);
 
             NAPI_OK(napi_set_property(env, obj, key, value));
         });
     } else {
-        DecodeObject(instance, origin, type, [&](Size i, const RecordMember &member, napi_value value) {
+        DecodeObject(instance, origin, type, [&](Size, const RecordMember &member, napi_value value) {
             NAPI_OK(napi_set_named_property(env, obj, member.name, value));
         });
     }
@@ -602,22 +621,19 @@ napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const Type
                 const char *ptr = (const char *)origin;
                 size_t count = strnlen(ptr, (size_t)len);
 
-                Napi::String str = Napi::String::New(env, ptr, count);
-                return str;
+                return NewString(env, ptr, count);
             } break;
             case PrimitiveKind::Int16: {
                 const char16_t *ptr = (const char16_t *)origin;
                 Size count = NullTerminatedLength(ptr, len);
 
-                Napi::String str = Napi::String::New(env, ptr, count);
-                return str;
+                return NewString(env, ptr, count);
             } break;
             case PrimitiveKind::Int32: {
                 const char32_t *ptr = (const char32_t *)origin;
                 Size count = NullTerminatedLength(ptr, len);
 
-                Napi::String str = MakeStringFromUTF32(env, ptr, count);
-                return str;
+                return NewString(env, ptr, count);
             } break;
 
             case PrimitiveKind::Void:
@@ -717,30 +733,30 @@ void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *ori
         case PrimitiveKind::String: {
             POP_ARRAY({
                 const char *str = *(const char **)src;
-                napi_set_element(env, array, i, str ? Napi::String::New(env, str) : env.Null());
+                napi_set_element(env, array, i, NewString(env, str));
 
                 if (ref->dispose) {
-                    ref->dispose(env, ref, str);
+                    ref->dispose(instance, ref, str);
                 }
             });
         } break;
         case PrimitiveKind::String16: {
             POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
-                napi_set_element(env, array, i, str16 ? Napi::String::New(env, str16) : env.Null());
+                napi_set_element(env, array, i, NewString(env, str16));
 
                 if (ref->dispose) {
-                    ref->dispose(env, ref, str16);
+                    ref->dispose(instance, ref, str16);
                 }
             });
         } break;
         case PrimitiveKind::String32: {
             POP_ARRAY({
                 const char32_t *str32 = *(const char32_t **)src;
-                napi_set_element(env, array, i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+                napi_set_element(env, array, i, NewString(env, str32));
 
                 if (ref->dispose) {
-                    ref->dispose(env, ref, str32);
+                    ref->dispose(instance, ref, str32);
                 }
             });
         } break;
@@ -748,11 +764,11 @@ void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *ori
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                napi_value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
+                napi_value p = WrapPointer(env, ref->ref.type, ptr2);
                 napi_set_element(env, array, i, p);
 
                 if (ref->dispose) {
-                    ref->dispose(env, ref, ptr2);
+                    ref->dispose(instance, ref, ptr2);
                 }
             });
         } break;
@@ -760,11 +776,11 @@ void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *ori
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                napi_value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
+                napi_value p = WrapPointer(env, ref->ref.type, ptr2);
                 napi_set_element(env, array, i, p);
 
                 if (ref->dispose) {
-                    ref->dispose(env, ref, ptr2);
+                    ref->dispose(instance, ref, ptr2);
                 }
             });
         } break;
@@ -786,7 +802,7 @@ void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *ori
                 float f;
                 memcpy(&f, src, 4);
 
-                napi_set_element(env, array, i, Napi::Number::New(env, (double)f));
+                napi_set_element(env, array, i, NewFloat(env, f));
             });
         } break;
         case PrimitiveKind::Float64: {
@@ -794,7 +810,7 @@ void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *ori
                 double d;
                 memcpy(&d, src, 8);
 
-                napi_set_element(env, array, i, Napi::Number::New(env, d));
+                napi_set_element(env, array, i, NewFloat(env, d));
             });
         } break;
 
@@ -888,23 +904,23 @@ napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *ty
         case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewInt); } break;
         case PrimitiveKind::String: {
             const char *str = *(const char **)ptr;
-            return str ? Napi::String::New(env, str) : env.Null();
+            return NewString(env, str);
         } break;
         case PrimitiveKind::String16: {
             const char16_t *str16 = *(const char16_t **)ptr;
-            return str16 ? Napi::String::New(env, str16) : env.Null();
+            return NewString(env, str16);
         } break;
         case PrimitiveKind::String32: {
             const char32_t *str32 = *(const char32_t **)ptr;
-            return str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+            return NewString(env, str32);
         } break;
         case PrimitiveKind::Pointer: {
             void *ptr2 = *(void **)ptr;
-            return ptr2 ? WrapPointer(env, type->ref.type, ptr2) : env.Null();
+            return WrapPointer(env, type->ref.type, ptr2);
         } break;
         case PrimitiveKind::Callback: {
             void *ptr2 = *(void **)ptr;
-            return ptr2 ? WrapPointer(env, type->ref.type, ptr2) : env.Null();
+            return WrapPointer(env, type->ref.type, ptr2);
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: { return DecodeObject(instance, ptr, type); } break;
@@ -916,13 +932,13 @@ napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *ty
             float f;
             memcpy(&f, ptr, 4);
 
-            return Napi::Number::New(env, (double)f);
+            return NewFloat(env, f);
         } break;
         case PrimitiveKind::Float64: {
             double d;
             memcpy(&d, ptr, 8);
 
-            return Napi::Number::New(env, d);
+            return NewFloat(env, d);
         } break;
 
         case PrimitiveKind::Prototype: {
@@ -944,7 +960,7 @@ napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *ty
             func->sync = proto->sync;
             func->async = proto->async;
 
-            return WrapFunction(env, func);
+            return WrapFunction(instance, func);
         } break;
     }
 
@@ -954,122 +970,6 @@ napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *ty
     return env.Null();
 }
 
-static bool CanTypeAcceptCallbacks(const TypeInfo *type)
-{
-    if (type->primitive == PrimitiveKind::Pointer)
-        return true;
-    if (type->primitive == PrimitiveKind::Callback)
-        return true;
-
-    if (type->primitive == PrimitiveKind::Record ||
-            type->primitive == PrimitiveKind::Union) {
-        for (const RecordMember &member: type->members) {
-            if (CanTypeAcceptCallbacks(member.type))
-                return false;
-        }
-    }
-
-    return true;
-}
-
-static bool CanUseFastCall(const FunctionInfo *func)
-{
-    if (func->parameters.len > 6)
-        return false;
-
-    // Fast calls basically skip CallData::Finalize(), which handles output arguments
-    // and temporary callback trampolines. If the function does not use any
-    // output argument and cannot accept callbacks (so no pointer or callback arguments),
-    // we can skip finalization!
-
-    for (const ParameterInfo &param: func->parameters) {
-        if (param.directions & 2)
-            return false;
-        if (CanTypeAcceptCallbacks(param.type))
-            return false;
-    }
-
-    return true;
-}
-
-napi_value DescribeFunction(Napi::Env env, const FunctionInfo *func)
-{
-    static const char *const DirectionNames[] = {
-        nullptr,
-        "Input",
-        "Output",
-        "Input/Output"
-    };
-
-    Napi::Object meta = Napi::Object::New(env);
-    Napi::Array arguments = Napi::Array::New(env, func->parameters.len);
-
-    meta.Set("name", Napi::String::New(env, func->name));
-    meta.Set("arguments", arguments);
-    meta.Set("result", WrapType(env, func->ret.type));
-
-    for (Size i = 0; i < func->parameters.len; i++) {
-        const ParameterInfo &param = func->parameters[i];
-        Napi::Object obj = Napi::Object::New(env);
-
-        obj.Set("type", WrapType(env, param.type));
-        obj.Set("direction", Napi::String::New(env, DirectionNames[param.directions]));
-
-        arguments.Set((uint32_t)i, obj);
-    }
-
-    meta.Freeze();
-
-    return meta;
-}
-
-static bool IsDebugAsyncEnabled()
-{
-    static bool debug = GetDebugFlag("DEBUG_ASYNC");
-    return debug;
-}
-
-napi_value WrapFunction(Napi::Env env, const FunctionInfo *func)
-{
-    Napi::Function wrapper;
-
-    // Pick appropriate wrapper
-    {
-        napi_value value;
-
-        if (func->variadic) {
-            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateVariadicCall, (void *)func->Ref(), &value));
-        } else if (IsDebugAsyncEnabled()) {
-            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCallDebugAsync, (void *)func->Ref(), &value));
-        } else if (!func->parameters.len) {
-            InstanceData *instance = env.GetInstanceData<InstanceData>();
-            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, instance->translate_zero_call, (void *)func->Ref(), &value));
-        } else if (CanUseFastCall(func)) {
-            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateFastCall, (void *)func->Ref(), &value));
-        } else {
-            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCall, (void *)func->Ref(), &value));
-        }
-
-        wrapper = Napi::Function(env, value);
-        wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
-    }
-
-    if (!func->variadic) {
-        napi_value value;
-        NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateAsyncCall, (void *)func->Ref(), &value));
-
-        Napi::Function async = Napi::Function(env, value);
-        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
-
-        wrapper.Set("async", async);
-    }
-
-    napi_value meta = DescribeFunction(env, func);
-    wrapper.Set("info", meta);
-
-    return wrapper;
-}
-
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention)
 {
     if (name == "__cdecl") {

package/src/koffi/src/util.hh

@@ -57,8 +57,6 @@ static FORCE_INLINE napi_valuetype GetKindOf(napi_env env, napi_value value)
 void SetValueTag(napi_env env, napi_value value, const void *marker);
 bool CheckValueTag(napi_env env, napi_value value, const void *marker);
 
-void DeleteReferenceSafe(napi_env env, napi_ref ref);
-
 static FORCE_INLINE bool IsNullOrUndefined(napi_valuetype kind)
 {
     return kind == napi_null || kind == napi_undefined;
@@ -343,39 +341,6 @@ static FORCE_INLINE bool TryBuffer(napi_env env, napi_value value, Span<uint8_t>
 
 int GetTypedArrayType(const TypeInfo *type);
 
-template <typename T>
-Size NullTerminatedLength(const T *ptr)
-{
-    Size len = 0;
-    while (ptr[len]) {
-        len++;
-    }
-    return len;
-}
-template <typename T>
-Size NullTerminatedLength(const T *ptr, Size max)
-{
-    Size len = 0;
-    while (len < max && ptr[len]) {
-        len++;
-    }
-    return len;
-}
-
-Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
-static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
-    { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
-
-napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
-void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type);
-
-napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
-napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
-
-napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type);
-
 static FORCE_INLINE napi_value NewInt(Napi::Env env, char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, signed char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, unsigned char i) { napi_value value; napi_create_uint32(env, (uint32_t)i, &value); return value; }
@@ -414,6 +379,83 @@ static FORCE_INLINE napi_value NewInt(Napi::Env env, T i)
     }
 }
 
+static FORCE_INLINE napi_value NewFloat(Napi::Env env, float f) { napi_value value; napi_create_double(env, (double)f, &value); return value; }
+static FORCE_INLINE napi_value NewFloat(Napi::Env env, double d) { napi_value value; napi_create_double(env, d, &value); return value; }
+
+template <typename T>
+static FORCE_INLINE Size NullTerminatedLength(const T *ptr)
+{
+    Size len = 0;
+    while (ptr[len]) {
+        len++;
+    }
+    return len;
+}
+template <typename T>
+static FORCE_INLINE Size NullTerminatedLength(const T *ptr, Size max)
+{
+    Size len = 0;
+    while (len < max && ptr[len]) {
+        len++;
+    }
+    return len;
+}
+
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char *ptr, Size len)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf8(env, ptr, (size_t)len, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char *ptr)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf8(env, ptr, NAPI_AUTO_LENGTH, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char16_t *ptr, Size len)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf16(env, ptr, (size_t)len, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char16_t *ptr)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf16(env, ptr, NAPI_AUTO_LENGTH, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+
+napi_value NewString(Napi::Env env, const char32_t *ptr, Size len);
+napi_value NewString(Napi::Env env, const char32_t *ptr);
+
+napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type);
+
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
+
+napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type);
+
 static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj)
 {
     K_ASSERT(IsObject(env, obj));
@@ -427,24 +469,23 @@ static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj
     return Napi::Array(env, result);
 }
 
-napi_value DescribeFunction(Napi::Env env, const FunctionInfo *func);
-napi_value WrapFunction(Napi::Env env, const FunctionInfo *func);
-
-static FORCE_INLINE napi_value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr)
+static FORCE_INLINE napi_value WrapPointer(Napi::Env env, const TypeInfo *, void *ptr)
 {
     napi_value value;
 
+    if (ptr) {
 #if defined(EXTERNAL_POINTERS)
-    NAPI_OK(napi_create_external(env, ptr, nullptr, nullptr, &value));
+        NAPI_OK(napi_create_external(env, ptr, nullptr, nullptr, &value));
 #else
-    NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)(uintptr_t)ptr, &value));
+        NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)(uintptr_t)ptr, &value));
 #endif
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
 
     return value;
 }
 
-bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
-
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
 void DumpMemory(const char *type, Span<const uint8_t> bytes);

package/src/koffi/src/uv.cc

@@ -104,7 +104,7 @@ void PollHandle::Start(const Napi::CallbackInfo &info)
 
 void PollHandle::Finalize(Napi::BasicEnv env)
 {
-    DeleteReferenceSafe(env, *this);
+    node_api_delete_reference(env, *this);
     SuppressDestruct();
 
     Close();

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

@@ -19,7 +19,7 @@ and exception handling semantics with low overhead.
 API references are available in the [doc](doc/README.md) directory.
 
 <!-- x-release-please-start-version -->
-## Current version: 8.5.0
+## Current version: 8.9.0
 <!-- x-release-please-end -->
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)