koffi 2.12.1 → 2.12.3

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

@@ -20,14 +20,14 @@ class TestWorkerWithUserDefRecv : public AsyncWorker {
   static void DoWorkWithAsyncRes(const CallbackInfo& info) {
     Object recv = info[0].As<Object>();
     Function cb = info[1].As<Function>();
-    Object resource = info[2].As<Object>();
+    Value resource = info[2];
 
     TestWorkerWithUserDefRecv* worker = nullptr;
     if (resource == info.Env().Null()) {
       worker = new TestWorkerWithUserDefRecv(recv, cb, "TestResource");
     } else {
-      worker =
-          new TestWorkerWithUserDefRecv(recv, cb, "TestResource", resource);
+      worker = new TestWorkerWithUserDefRecv(
+          recv, cb, "TestResource", resource.As<Object>());
     }
 
     worker->Queue();
@@ -51,15 +51,17 @@ class TestWorkerWithUserDefRecv : public AsyncWorker {
 };
 
 // Using default std::allocator impl, but assuming user can define their own
-// alloc/dealloc methods
+// allocate/deallocate methods
 class CustomAllocWorker : public AsyncWorker {
+  using Allocator = std::allocator<CustomAllocWorker>;
+
  public:
   CustomAllocWorker(Function& cb) : AsyncWorker(cb){};
   static void DoWork(const CallbackInfo& info) {
     Function cb = info[0].As<Function>();
-    std::allocator<CustomAllocWorker> create_alloc;
-    CustomAllocWorker* newWorker = create_alloc.allocate(1);
-    create_alloc.construct(newWorker, cb);
+    Allocator allocator;
+    CustomAllocWorker* newWorker = allocator.allocate(1);
+    std::allocator_traits<Allocator>::construct(allocator, newWorker, cb);
     newWorker->Queue();
   }
 
@@ -67,9 +69,9 @@ class CustomAllocWorker : public AsyncWorker {
   void Execute() override {}
   void Destroy() override {
     assert(this->_secretVal == 24);
-    std::allocator<CustomAllocWorker> deallocer;
-    deallocer.destroy(this);
-    deallocer.deallocate(this, 1);
+    Allocator allocator;
+    std::allocator_traits<Allocator>::destroy(allocator, this);
+    allocator.deallocate(this, 1);
   }
 
  private:
@@ -108,7 +110,7 @@ class TestWorker : public AsyncWorker {
       : AsyncWorker(cb, resource_name, resource) {}
   TestWorker(Function cb, const char* resource_name)
       : AsyncWorker(cb, resource_name) {}
-  bool _succeed;
+  bool _succeed{};
 };
 
 class TestWorkerWithResult : public AsyncWorker {
@@ -143,7 +145,7 @@ class TestWorkerWithResult : public AsyncWorker {
                        const char* resource_name,
                        const Object& resource)
       : AsyncWorker(cb, resource_name, resource) {}
-  bool _succeed;
+  bool _succeed{};
 };
 
 class TestWorkerNoCallback : public AsyncWorker {
@@ -194,7 +196,7 @@ class TestWorkerNoCallback : public AsyncWorker {
       : AsyncWorker(env, resource_name, resource),
         _deferred(Napi::Promise::Deferred::New(env)) {}
   Promise::Deferred _deferred;
-  bool _succeed;
+  bool _succeed{};
 };
 
 class EchoWorker : public AsyncWorker {

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

@@ -139,7 +139,7 @@ async function test (binding) {
         {
           eventName: 'init',
           type: 'TestResource',
-          triggerAsyncId: triggerAsyncId,
+          triggerAsyncId,
           resource: { foo: 'fooBar' }
         },
         { eventName: 'before' },
@@ -167,7 +167,7 @@ async function test (binding) {
         {
           eventName: 'init',
           type: 'TestResource',
-          triggerAsyncId: triggerAsyncId,
+          triggerAsyncId,
           resource: { }
         },
         { eventName: 'before' },
@@ -194,7 +194,7 @@ async function test (binding) {
         {
           eventName: 'init',
           type: 'TestResource',
-          triggerAsyncId: triggerAsyncId,
+          triggerAsyncId,
           resource: { foo: 'foo' }
         },
         { eventName: 'before' },
@@ -224,7 +224,7 @@ async function test (binding) {
         {
           eventName: 'init',
           type: 'TestResource',
-          triggerAsyncId: triggerAsyncId,
+          triggerAsyncId,
           resource: { foo: 'foo' }
         },
         { eventName: 'before' },
@@ -252,7 +252,7 @@ async function test (binding) {
         {
           eventName: 'init',
           type: 'TestResource',
-          triggerAsyncId: triggerAsyncId,
+          triggerAsyncId,
           resource: { foo: 'foo' }
         },
         { eventName: 'before' },

package/vendor/node-addon-api/test/basic_types/value.cc

@@ -128,6 +128,11 @@ static Value ToObject(const CallbackInfo& info) {
   return MaybeUnwrap(info[0].ToObject());
 }
 
+static Value AccessProp(const CallbackInfo& info) {
+  Object obj = MaybeUnwrap(info[0].ToObject());
+  return obj[info[1]].AsValue();
+}
+
 Object InitBasicTypesValue(Env env) {
   Object exports = Object::New(env);
 
@@ -150,6 +155,7 @@ Object InitBasicTypesValue(Env env) {
   exports["toNumber"] = Function::New(env, ToNumber);
   exports["toString"] = Function::New(env, ToString);
   exports["toObject"] = Function::New(env, ToObject);
+  exports["accessProp"] = Function::New(env, AccessProp);
 
   exports["strictlyEquals"] = Function::New(env, StrictlyEquals);
   exports["strictlyEqualsOverload"] = Function::New(env, StrictEqualsOverload);

package/vendor/node-addon-api/test/basic_types/value.js

@@ -117,6 +117,21 @@ function test (binding) {
     assert(value.assertNonEmptyReturnValOnCast());
   }
 
+  function accessPropTest (value) {
+    const testObject = { key: '123' };
+    const testSymbol = Symbol('123');
+    const testNumber = 123;
+    const destObj = {
+      testObject,
+      testSymbol,
+      [testNumber]: testNumber
+    };
+    assert.strictEqual(value.accessProp(destObj, 'testObject'), testObject);
+    assert.strictEqual(value.accessProp(destObj, 'testSymbol'), testSymbol);
+    assert.strictEqual(value.accessProp(destObj, testNumber), testNumber);
+    assert.strictEqual(value.accessProp(destObj, 'invalidKey'), undefined);
+  }
+
   const value = binding.basic_types_value;
 
   assertValueStrictlyEqual(value);
@@ -153,4 +168,6 @@ function test (binding) {
   assert.strictEqual(value.toString(null), 'null');
 
   typeConverterTest(value.toObject, Object);
+
+  accessPropTest(value);
 }

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

@@ -86,6 +86,7 @@ Object InitEnvMiscellaneous(Env env);
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
 Object InitMaybeCheck(Env env);
 #endif
+Object InitFinalizerOrder(Env env);
 
 Object Init(Env env, Object exports) {
 #if (NAPI_VERSION > 5)
@@ -186,6 +187,13 @@ Object Init(Env env, Object exports) {
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
   exports.Set("maybe_check", InitMaybeCheck(env));
 #endif
+
+  exports.Set("finalizer_order", InitFinalizerOrder(env));
+
+  exports.Set(
+      "isExperimental",
+      Napi::Boolean::New(env, NAPI_VERSION == NAPI_VERSION_EXPERIMENTAL));
+
   return exports;
 }
 

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

@@ -30,6 +30,7 @@
         'error.cc',
         'error_handling_for_primitives.cc',
         'external.cc',
+        'finalizer_order.cc',
         'function.cc',
         'function_reference.cc',
         'handlescope.cc',
@@ -84,21 +85,42 @@
         'binding-swallowexcept.cc',
         'error.cc',
       ],
+      'build_sources_except_all': [
+        'except_all.cc',
+      ],
       'build_sources_type_check': [
         'value_type_cast.cc'
       ],
+      'want_coverage': '<!(node -p process.env.npm_config_coverage)',
+      'use_node_api_headers': '<!(node -p process.env.use_node_api_headers)',
       'conditions': [
         ['disable_deprecated!="true"', {
           'build_sources': ['object/object_deprecated.cc']
         }]
       ]
     },
+    'conditions': [
+      ['want_coverage=="true" and OS=="linux"', {
+        'cflags_cc': ['--coverage'],
+        'ldflags': ['--coverage'],
+      }],
+      ['use_node_api_headers=="true"', {
+        # prepend to the include_dirs list
+        'include_dirs+': ["<!(node -p \"require('node-api-headers').include_dir\")"],
+      }],
+    ],
   },
   'targets': [
     {
       'target_name': 'binding',
       'dependencies': ['../node_addon_api.gyp:node_addon_api_except'],
-      'sources': ['>@(build_sources)']
+      'sources': ['>@(build_sources)'],
+      'defines': ['NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS']
+    },
+    {
+      'target_name': 'binding_except_all',
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_except_all'],
+      'sources': [ '>@(build_sources_except_all)']
     },
     {
       'target_name': 'binding_noexcept',

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

@@ -2,7 +2,6 @@
 
 const assert = require('assert');
 const testUtil = require('./testUtil');
-const safeBuffer = require('safe-buffer');
 
 module.exports = require('./common').runTest(test);
 
@@ -14,7 +13,7 @@ function test (binding) {
       binding.buffer.checkBuffer(test);
       assert.ok(test instanceof Buffer);
 
-      const test2 = safeBuffer.Buffer.alloc(test.length);
+      const test2 = Buffer.alloc(test.length);
       test.copy(test2);
       binding.buffer.checkBuffer(test2);
     },

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

@@ -142,7 +142,7 @@ async function checkBuildType (buildType) {
 
 async function whichBuildType () {
   let buildType = 'Release';
-  const envBuildType = process.env.NODE_API_BUILD_CONFIG;
+  const envBuildType = process.env.NODE_API_BUILD_CONFIG || (process.env.npm_config_debug === 'true' ? 'Debug' : 'Release');
   if (envBuildType) {
     if (Object.values(buildTypes).includes(envBuildType)) {
       if (await checkBuildType(envBuildType)) {

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

@@ -0,0 +1,22 @@
+#include <stdexcept>
+#include "napi.h"
+
+using namespace Napi;
+
+void ThrowStdException(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+  throw std::runtime_error(message);
+}
+
+void ThrowPrimitiveException(const CallbackInfo&) {
+  throw 0;
+}
+
+Object Init(Env env, Object exports) {
+  exports.Set("throwStdException", Napi::Function::New(env, ThrowStdException));
+  exports.Set("throwPrimitiveException",
+              Napi::Function::New(env, ThrowPrimitiveException));
+  return exports;
+}
+
+NODE_API_MODULE(addon, Init)

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

@@ -0,0 +1,14 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTestWithBuildType(test);
+
+function test (buildType) {
+  const binding = require(`./build/${buildType}/binding_except_all.node`);
+
+  const message = 'error message';
+  assert.throws(binding.throwStdException.bind(undefined, message), { message });
+
+  assert.throws(binding.throwPrimitiveException.bind(undefined), { message: 'A native exception was thrown' });
+}

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const { strictEqual } = require('assert');
+const { valid } = require('semver');
+
+const nodeAddonApi = require('../');
+
+module.exports = function test () {
+  strictEqual(nodeAddonApi.include.startsWith('"'), true);
+  strictEqual(nodeAddonApi.include.endsWith('"'), true);
+  strictEqual(nodeAddonApi.include.includes('node-addon-api'), true);
+  strictEqual(nodeAddonApi.include_dir, '');
+  strictEqual(nodeAddonApi.gyp, 'node_api.gyp:nothing');
+  strictEqual(nodeAddonApi.targets, 'node_addon_api.gyp');
+  strictEqual(valid(nodeAddonApi.version), true);
+  strictEqual(nodeAddonApi.version, require('../package.json').version);
+  strictEqual(nodeAddonApi.isNodeApiBuiltin, true);
+  strictEqual(nodeAddonApi.needsFlag, false);
+};

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

@@ -0,0 +1,152 @@
+#include <napi.h>
+
+namespace {
+class Test : public Napi::ObjectWrap<Test> {
+ public:
+  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
+    basicFinalizerCalled = false;
+    finalizerCalled = false;
+
+    if (info.Length() > 0) {
+      finalizeCb_ = Napi::Persistent(info[0].As<Napi::Function>());
+    }
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    exports.Set("Test",
+                DefineClass(env,
+                            "Test",
+                            {
+                                StaticAccessor("isBasicFinalizerCalled",
+                                               &IsBasicFinalizerCalled,
+                                               nullptr,
+                                               napi_default),
+                                StaticAccessor("isFinalizerCalled",
+                                               &IsFinalizerCalled,
+                                               nullptr,
+                                               napi_default),
+                            }));
+  }
+
+  void Finalize(Napi::BasicEnv /*env*/) { basicFinalizerCalled = true; }
+
+  void Finalize(Napi::Env /*env*/) {
+    finalizerCalled = true;
+    if (!finalizeCb_.IsEmpty()) {
+      finalizeCb_.Call({});
+    }
+  }
+
+  static Napi::Value IsBasicFinalizerCalled(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), basicFinalizerCalled);
+  }
+
+  static Napi::Value IsFinalizerCalled(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), finalizerCalled);
+  }
+
+ private:
+  Napi::FunctionReference finalizeCb_;
+
+  static bool basicFinalizerCalled;
+  static bool finalizerCalled;
+};
+
+bool Test::basicFinalizerCalled = false;
+bool Test::finalizerCalled = false;
+
+bool externalBasicFinalizerCalled = false;
+bool externalFinalizerCalled = false;
+
+Napi::Value CreateExternalBasicFinalizer(const Napi::CallbackInfo& info) {
+  externalBasicFinalizerCalled = false;
+  return Napi::External<int>::New(
+      info.Env(), new int(1), [](Napi::BasicEnv /*env*/, int* data) {
+        externalBasicFinalizerCalled = true;
+        delete data;
+      });
+}
+
+Napi::Value CreateExternalFinalizer(const Napi::CallbackInfo& info) {
+  externalFinalizerCalled = false;
+  return Napi::External<int>::New(
+      info.Env(), new int(1), [](Napi::Env /*env*/, int* data) {
+        externalFinalizerCalled = true;
+        delete data;
+      });
+}
+
+Napi::Value isExternalBasicFinalizerCalled(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), externalBasicFinalizerCalled);
+}
+
+Napi::Value IsExternalFinalizerCalled(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), externalFinalizerCalled);
+}
+
+#ifdef NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
+Napi::Value PostFinalizer(const Napi::CallbackInfo& info) {
+  auto env = info.Env();
+
+  env.PostFinalizer([callback = Napi::Persistent(info[0].As<Napi::Function>())](
+                        Napi::Env /*env*/) { callback.Call({}); });
+
+  return env.Undefined();
+}
+
+Napi::Value PostFinalizerWithData(const Napi::CallbackInfo& info) {
+  auto env = info.Env();
+
+  env.PostFinalizer(
+      [callback = Napi::Persistent(info[0].As<Napi::Function>())](
+          Napi::Env /*env*/, Napi::Reference<Napi::Value>* data) {
+        callback.Call({data->Value()});
+        delete data;
+      },
+      new Napi::Reference<Napi::Value>(Napi::Persistent(info[1])));
+
+  return env.Undefined();
+}
+
+Napi::Value PostFinalizerWithDataAndHint(const Napi::CallbackInfo& info) {
+  auto env = info.Env();
+
+  env.PostFinalizer(
+      [callback = Napi::Persistent(info[0].As<Napi::Function>())](
+          Napi::Env /*env*/,
+          Napi::Reference<Napi::Value>* data,
+          Napi::Reference<Napi::Value>* hint) {
+        callback.Call({data->Value(), hint->Value()});
+        delete data;
+        delete hint;
+      },
+      new Napi::Reference<Napi::Value>(Napi::Persistent(info[1])),
+      new Napi::Reference<Napi::Value>(Napi::Persistent(info[2])));
+
+  return env.Undefined();
+}
+#endif
+
+}  // namespace
+
+Napi::Object InitFinalizerOrder(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  Test::Initialize(env, exports);
+  exports["createExternalBasicFinalizer"] =
+      Napi::Function::New(env, CreateExternalBasicFinalizer);
+  exports["createExternalFinalizer"] =
+      Napi::Function::New(env, CreateExternalFinalizer);
+  exports["isExternalBasicFinalizerCalled"] =
+      Napi::Function::New(env, isExternalBasicFinalizerCalled);
+  exports["isExternalFinalizerCalled"] =
+      Napi::Function::New(env, IsExternalFinalizerCalled);
+
+#ifdef NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
+  exports["PostFinalizer"] = Napi::Function::New(env, PostFinalizer);
+  exports["PostFinalizerWithData"] =
+      Napi::Function::New(env, PostFinalizerWithData);
+  exports["PostFinalizerWithDataAndHint"] =
+      Napi::Function::New(env, PostFinalizerWithDataAndHint);
+#endif
+  return exports;
+}

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

@@ -0,0 +1,98 @@
+'use strict';
+
+/* eslint-disable no-unused-vars */
+
+const assert = require('assert');
+const common = require('./common');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding) {
+  const { isExperimental } = binding;
+
+  let isCallbackCalled = false;
+
+  const tests = [
+    'Finalizer Order - ObjectWrap',
+    () => {
+      let test = new binding.finalizer_order.Test(() => { isCallbackCalled = true; });
+      test = null;
+
+      global.gc();
+
+      if (isExperimental) {
+        assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, true, 'Expected basic finalizer to be called [before ticking]');
+        assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, false, 'Expected (extended) finalizer to not be called [before ticking]');
+        assert.strictEqual(isCallbackCalled, false, 'Expected callback to not be called [before ticking]');
+      } else {
+        assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, false, 'Expected basic finalizer to not be called [before ticking]');
+        assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, false, 'Expected (extended) finalizer to not be called [before ticking]');
+        assert.strictEqual(isCallbackCalled, false, 'Expected callback to not be called [before ticking]');
+      }
+    },
+    () => {
+      assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, true, 'Expected basic finalizer to be called [after ticking]');
+      assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, true, 'Expected (extended) finalizer to be called [after ticking]');
+      assert.strictEqual(isCallbackCalled, true, 'Expected callback to be called [after ticking]');
+    },
+
+    'Finalizer Order - External with Basic Finalizer',
+    () => {
+      let ext = binding.finalizer_order.createExternalBasicFinalizer();
+      ext = null;
+      global.gc();
+
+      if (isExperimental) {
+        assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), true, 'Expected External basic finalizer to be called [before ticking]');
+      } else {
+        assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), false, 'Expected External basic finalizer to not be called [before ticking]');
+      }
+    },
+    () => {
+      assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), true, 'Expected External basic finalizer to be called [after ticking]');
+    },
+
+    'Finalizer Order - External with Finalizer',
+    () => {
+      let ext = binding.finalizer_order.createExternalFinalizer();
+      ext = null;
+      global.gc();
+      assert.strictEqual(binding.finalizer_order.isExternalFinalizerCalled(), false, 'Expected External extended finalizer to not be called [before ticking]');
+    },
+    () => {
+      assert.strictEqual(binding.finalizer_order.isExternalFinalizerCalled(), true, 'Expected External extended finalizer to be called [after ticking]');
+    }
+  ];
+
+  if (binding.isExperimental) {
+    tests.push(...[
+      'PostFinalizer',
+      () => {
+        binding.finalizer_order.PostFinalizer(common.mustCall());
+      },
+
+      'PostFinalizerWithData',
+      () => {
+        const data = {};
+        const callback = (callbackData) => {
+          assert.strictEqual(callbackData, data);
+        };
+        binding.finalizer_order.PostFinalizerWithData(common.mustCall(callback), data);
+      },
+
+      'PostFinalizerWithDataAndHint',
+      () => {
+        const data = {};
+        const hint = {};
+        const callback = (callbackData, callbackHint) => {
+          assert.strictEqual(callbackData, data);
+          assert.strictEqual(callbackHint, hint);
+        };
+        binding.finalizer_order.PostFinalizerWithDataAndHint(common.mustCall(callback), data, hint);
+      }
+    ]);
+  }
+
+  return testUtil.runGCTests(tests);
+}

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

@@ -18,7 +18,7 @@ function test (binding) {
 
   assert.deepStrictEqual(binding.valueCallback(), { foo: 'bar' });
 
-  /* eslint-disable-next-line no-new, new-cap */
+  /* eslint-disable-next-line new-cap */
   assert.strictEqual(new binding.newTargetCallback(), binding.newTargetCallback);
   assert.strictEqual(binding.newTargetCallback(), undefined);
 
@@ -89,7 +89,7 @@ function test (binding) {
   assert.deepStrictEqual(args, [7, 8, 9]);
 
   assert.throws(() => {
-    binding.callWithInvalidReceiver();
+    binding.callWithInvalidReceiver(() => {});
   }, /Invalid (pointer passed as )?argument/);
 
   obj = binding.callConstructorWithArgs(testConstructor, 5, 6, 7);

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

@@ -95,7 +95,7 @@ async function canCallAsyncFunctionWithDifferentOverloads (binding) {
     {
       eventName: 'init',
       type: 'func_ref_resources',
-      triggerAsyncId: triggerAsyncId,
+      triggerAsyncId,
       resource: {}
     },
     { eventName: 'before' },
@@ -113,7 +113,7 @@ async function canCallAsyncFunctionWithDifferentOverloads (binding) {
     {
       eventName: 'init',
       type: 'func_ref_resources',
-      triggerAsyncId: triggerAsyncId,
+      triggerAsyncId,
       resource: {}
     },
     { eventName: 'before' },

package/vendor/node-addon-api/test/globalObject/global_object_delete_property.cc

@@ -5,27 +5,27 @@ using namespace Napi;
 
 Value DeletePropertyWithCStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   return Boolean::New(
       info.Env(), MaybeUnwrap(globalObject.Delete(key.Utf8Value().c_str())));
 }
 
 Value DeletePropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   return Boolean::New(info.Env(),
                       MaybeUnwrap(globalObject.Delete(key.Utf8Value())));
 }
 
 Value DeletePropertyWithInt32AsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Number key = info[0].As<Number>();
+  Number key = info[0].UnsafeAs<Number>();
   return Boolean::New(info.Env(),
                       MaybeUnwrap(globalObject.Delete(key.Uint32Value())));
 }
 
 Value DeletePropertyWithNapiValueAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
+  Name key = info[0].UnsafeAs<Name>();
   return Boolean::New(info.Env(), MaybeUnwrap(globalObject.Delete(key)));
 }