koffi 0.9.33 → 0.9.34

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

@@ -1,31 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value().c_str(), value);
-}
-
-void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value(), value);
-}
-
-void SetPropertyWithInt32AsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Number key = info[0].As<Number>();
-  Value value = info[1];
-  globalObject.Set(key.Uint32Value(), value);
-}
-
-void SetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
-  Value value = info[1];
-  globalObject.Set(key, value);
-}

package/vendor/node-addon-api/test/globalObject/global_object_set_property.js

@@ -1,58 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  const KEY_TYPE = {
-        C_STR: 'KEY_AS_C_STRING',
-        CPP_STR: 'KEY_AS_CPP_STRING',
-        NAPI:  'KEY_AS_NAPI_VALUES',
-        INT_32: 'KEY_AS_INT_32_NUM'
-    };
-
-    function setGlobalObjectKeyValue(key, value, keyType) {
-        switch(keyType)
-        {
-            case KEY_TYPE.CPP_STR:
-            binding.globalObject.setPropertyWithCppStyleString(key,value);
-            break;
-
-            case KEY_TYPE.C_STR:
-            binding.globalObject.setPropertyWithCStyleString(key,value);
-            break;
-
-            case KEY_TYPE.INT_32:
-            binding.globalObject.setPropertyWithInt32(key,value);
-            break;
-
-            case KEY_TYPE.NAPI:
-            binding.globalObject.setPropertyWithNapiValue(key,value);
-            break;
-        }
-    }
-
-    function assertErrMessageIsThrown(nativeObjectSetFunction, errMsg) {
-        assert.throws(() => {
-          nativeObjectSetFunction(undefined, 1);
-        }, errMsg);
-      }
-
-
-    setGlobalObjectKeyValue("cKey","cValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue(1,10,KEY_TYPE.INT_32);
-    setGlobalObjectKeyValue("napi_key","napi_value",KEY_TYPE.NAPI);
-    setGlobalObjectKeyValue("cppKey","cppValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue("circular",global,KEY_TYPE.NAPI);
-
-    assert.deepStrictEqual(global["circular"], global);
-    assert.deepStrictEqual(global["cppKey"],"cppValue");
-    assert.deepStrictEqual(global["napi_key"],"napi_value");
-    assert.deepStrictEqual(global[1],10);
-    assert.deepStrictEqual(global["cKey"],"cValue");
-
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
-}

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

@@ -1,60 +0,0 @@
-#include "napi.h"
-#include "string.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace Napi;
-
-Value createScope(const CallbackInfo& info) {
-  {
-    HandleScope scope(info.Env());
-    String::New(info.Env(), "inner-scope");
-  }
-  return String::New(info.Env(), "scope");
-}
-
-Value escapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-#define LOOP_MAX 1000000
-Value stressEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  for (int i = 0; i < LOOP_MAX; i++) {
-    EscapableHandleScope scope(info.Env());
-    char buffer[128];
-    snprintf(buffer, 128, "%d", i);
-    std::string name = std::string("inner-scope") + std::string(buffer);
-    Value newValue = String::New(info.Env(), name.c_str());
-    if (i == (LOOP_MAX -1)) {
-      result = scope.Escape(newValue);
-    }
-  }
-  return result;
-}
-
-Value doubleEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-Object InitHandleScope(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createScope"] = Function::New(env, createScope);
-  exports["escapeFromScope"] = Function::New(env, escapeFromScope);
-  exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
-  exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
-
-  return exports;
-}

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

@@ -1,14 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  assert.strictEqual(binding.handlescope.createScope(), 'scope');
-  assert.strictEqual(binding.handlescope.escapeFromScope(), 'inner-scope');
-  assert.strictEqual(binding.handlescope.stressEscapeFromScope(), 'inner-scope999999');
-  assert.throws(() => binding.handlescope.doubleEscapeFromScope(),
-                Error,
-                ' napi_escape_handle already called on scope');
-}

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

@@ -1,159 +0,0 @@
-'use strict';
-
-const majorNodeVersion = process.versions.node.split('.')[0];
-
-if (typeof global.gc !== 'function') {
-  // Construct the correct (version-dependent) command-line args.
-  const args = ['--expose-gc'];
-  const majorV8Version = process.versions.v8.split('.')[0];
-  if (majorV8Version < 9) {
-    args.push('--no-concurrent-array-buffer-freeing');
-  }
-  if (majorNodeVersion >= 14) {
-    args.push('--no-concurrent-array-buffer-sweeping');
-  }
-  args.push(__filename);
-
-  const child = require('./napi_child').spawnSync(process.argv[0], args, {
-    stdio: 'inherit'
-  });
-
-  if (child.signal) {
-    console.error(`Tests aborted with ${child.signal}`);
-    process.exitCode = 1;
-  } else {
-    process.exitCode = child.status;
-  }
-  process.exit(process.exitCode);
-}
-
-const testModules = [];
-
-const fs = require('fs');
-const path = require('path');
-
-let filterCondition = process.env.npm_config_filter || '';
-let filterConditionFiles = [];
-
-if (filterCondition !== '') {
-  filterCondition = require('../unit-test/matchModules').matchWildCards(process.env.npm_config_filter);
-  filterConditionFiles = filterCondition.split(' ').length > 0 ? filterCondition.split(' ') : [filterCondition];
-}
-
-const filterConditionsProvided = filterConditionFiles.length > 0;
-
-function checkFilterCondition (fileName, parsedFilepath) {
-  let result = false;
-
-  if (!filterConditionsProvided) return true;
-  if (filterConditionFiles.includes(parsedFilepath)) result = true;
-  if (filterConditionFiles.includes(fileName)) result = true;
-  return result;
-}
-
-// TODO(RaisinTen): Update this when the test filenames
-// are changed into test_*.js.
-function loadTestModules (currentDirectory = __dirname, pre = '') {
-  fs.readdirSync(currentDirectory).forEach((file) => {
-    if (currentDirectory === __dirname && (
-      file === 'binding.cc' ||
-          file === 'binding.gyp' ||
-          file === 'build' ||
-          file === 'common' ||
-          file === 'napi_child.js' ||
-          file === 'testUtil.js' ||
-          file === 'thunking_manual.cc' ||
-          file === 'thunking_manual.js' ||
-          file === 'index.js' ||
-          file[0] === '.')) {
-      return;
-    }
-    const absoluteFilepath = path.join(currentDirectory, file);
-    const parsedFilepath = path.parse(file);
-    const parsedPath = path.parse(currentDirectory);
-
-    if (fs.statSync(absoluteFilepath).isDirectory()) {
-      if (fs.existsSync(absoluteFilepath + '/index.js')) {
-        if (checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
-          testModules.push(pre + file);
-        }
-      } else {
-        loadTestModules(absoluteFilepath, pre + file + '/');
-      }
-    } else {
-      if (parsedFilepath.ext === '.js' && checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
-        testModules.push(pre + parsedFilepath.name);
-      }
-    }
-  });
-}
-
-loadTestModules();
-
-process.config.target_defaults.default_configuration =
-  fs
-    .readdirSync(path.join(__dirname, process.env.REL_BUILD_PATH || '', 'build'))
-    .filter((item) => (item === 'Debug' || item === 'Release'))[0];
-
-let napiVersion = Number(process.versions.napi);
-if (process.env.NAPI_VERSION) {
-  // we need this so that we don't try run tests that rely
-  // on methods that are not available in the NAPI_VERSION
-  // specified
-  napiVersion = process.env.NAPI_VERSION;
-}
-console.log('napiVersion:' + napiVersion);
-
-if (napiVersion < 3) {
-  testModules.splice(testModules.indexOf('env_cleanup'), 1);
-  testModules.splice(testModules.indexOf('callbackscope'), 1);
-  testModules.splice(testModules.indexOf('version_management'), 1);
-}
-
-if (napiVersion < 4 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('asyncprogressqueueworker'), 1);
-  testModules.splice(testModules.indexOf('asyncprogressworker'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ctx'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_existing_tsfn'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ptr'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_sum'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_unref'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
-}
-
-if (napiVersion < 5 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('date'), 1);
-}
-
-if (napiVersion < 6 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('addon'), 1);
-  testModules.splice(testModules.indexOf('addon_data'), 1);
-  testModules.splice(testModules.indexOf('bigint'), 1);
-  testModules.splice(testModules.indexOf('typedarray-bigint'), 1);
-}
-
-if (majorNodeVersion < 12 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
-  testModules.splice(testModules.indexOf('error_terminating_environment'), 1);
-}
-
-if (napiVersion < 8 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
-}
-
-(async function () {
-  console.log(`Testing with Node-API Version '${napiVersion}'.`);
-
-  if (filterConditionsProvided) { console.log('Starting test suite\n', testModules); } else { console.log('Starting test suite\n'); }
-
-  // Requiring each module runs tests in the module.
-  for (const name of testModules) {
-    console.log(`Running test '${name}'`);
-    await require('./' + name);
-  }
-
-  console.log('\nAll tests passed!');
-})().catch((error) => {
-  console.log(error);
-  process.exit(1);
-});

package/vendor/node-addon-api/test/maybe/check.cc

@@ -1,23 +0,0 @@
-#include "napi.h"
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-
-using namespace Napi;
-
-namespace {
-
-void VoidCallback(const CallbackInfo& info) {
-  Function fn = info[0].As<Function>();
-
-  Maybe<Value> it = fn.Call({});
-
-  it.Check();
-}
-
-}  // end anonymous namespace
-
-Object InitMaybeCheck(Env env) {
-  Object exports = Object::New(env);
-  exports.Set("voidCallback", Function::New(env, VoidCallback));
-  return exports;
-}
-#endif

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

@@ -1,38 +0,0 @@
-'use strict';
-
-const buildType = process.config.target_defaults.default_configuration;
-const assert = require('assert');
-const os = require('os');
-
-const napiChild = require('../napi_child');
-
-module.exports = test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
-
-function test(binding) {
-  if (process.argv.includes('child')) {
-    child(binding);
-    return;
-  }
-  const cp = napiChild.spawn(process.execPath, [__filename, 'child'], {
-    stdio: ['ignore', 'inherit', 'pipe'],
-  });
-  cp.stderr.setEncoding('utf8');
-  let stderr = '';
-  cp.stderr.on('data', chunk => {
-    stderr += chunk;
-  });
-  cp.on('exit', (code, signal) => {
-    if (process.platform === 'win32') {
-      assert.strictEqual(code, 128 + 6 /* SIGABRT */);
-    } else {
-      assert.strictEqual(signal, 'SIGABRT');
-    }
-    assert.ok(stderr.match(/FATAL ERROR: Napi::Maybe::Check Maybe value is Nothing./));
-  });
-}
-
-function child(binding) {
-  binding.voidCallback(() => {
-    throw new Error('foobar');
-  })
-}

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

@@ -1,17 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value externalAllocatedMemory(const CallbackInfo& info) {
-    int64_t kSize = 1024 * 1024;
-    int64_t baseline = MemoryManagement::AdjustExternalMemory(info.Env(), 0);
-    int64_t tmp = MemoryManagement::AdjustExternalMemory(info.Env(), kSize);
-    tmp = MemoryManagement::AdjustExternalMemory(info.Env(), -kSize);
-    return Boolean::New(info.Env(), tmp == baseline);
-}
-
-Object InitMemoryManagement(Env env) {
-    Object exports = Object::New(env);
-    exports["externalAllocatedMemory"] = Function::New(env, externalAllocatedMemory);
-    return exports;
-}

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

@@ -1,9 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-    assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true)
-}

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

@@ -1,23 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value createExternal(const CallbackInfo& info) {
-  FunctionReference ref = Reference<Function>::New(info[0].As<Function>(), 1);
-  auto ret = External<char>::New(
-      info.Env(),
-      nullptr,
-      [ref = std::move(ref)](Napi::Env /*env*/, char* /*data*/) {
-        ref.Call({});
-      });
-
-  return ret;
-}
-
-Object InitMovableCallbacks(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createExternal"] = Function::New(env, createExternal);
-
-  return exports;
-}

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

@@ -1,21 +0,0 @@
-'use strict';
-
-const common = require('./common');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(binding => test(binding.movable_callbacks));
-
-async function test(binding) {
-  await testUtil.runGCTests([
-    'External',
-    () => {
-      const fn = common.mustCall(() => {
-        // noop
-      }, 1);
-      const external = binding.createExternal(fn);
-    },
-    () => {
-      // noop, wait for gc
-    }
-  ]);
-}

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

@@ -1,108 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-const char* testValueUtf8 = "123456789";
-const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
-
-Value EchoString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    return String::New(info.Env(), value.Utf8Value().c_str());
-  } else if (encoding.Utf8Value() == "utf16") {
-    return String::New(info.Env(), value.Utf16Value().c_str());
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateString(const CallbackInfo& info) {
-  String encoding = info[0].As<String>();
-  Number length = info[1].As<Number>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf8);
-    } else {
-      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
-    }
-  } else if (encoding.Utf8Value() == "utf16") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf16);
-    } else {
-      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
-    }
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CheckString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-  Number length = info[2].As<Number>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    std::string testValue = testValueUtf8;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
-    }
-
-    std::string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else if (encoding.Utf8Value() == "utf16") {
-    std::u16string testValue = testValueUtf16;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
-    }
-
-    std::u16string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateSymbol(const CallbackInfo& info) {
-  String description = info[0].As<String>();
-
-  if (!description.IsUndefined()) {
-    return Symbol::New(info.Env(), description);
-  } else {
-    return Symbol::New(info.Env());
-  }
-}
-
-Value CheckSymbol(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
-}
-
-void NullStringShouldThrow(const CallbackInfo& info) {
-  const char* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-void NullString16ShouldThrow(const CallbackInfo& info) {
-  const char16_t* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-Object InitName(Env env) {
-  Object exports = Object::New(env);
-
-  exports["echoString"] = Function::New(env, EchoString);
-  exports["createString"] = Function::New(env, CreateString);
-  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
-  exports["nullString16ShouldThrow"] =
-      Function::New(env, NullString16ShouldThrow);
-  exports["checkString"] = Function::New(env, CheckString);
-  exports["createSymbol"] = Function::New(env, CreateSymbol);
-  exports["checkSymbol"] = Function::New(env, CheckSymbol);
-
-  return exports;
-}

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

@@ -1,59 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  const expected = '123456789';
-
-
-  assert.throws(binding.name.nullStringShouldThrow, {
-    name: 'Error',
-    message: 'Error in native callback',
-  });
-  assert.ok(binding.name.checkString(expected, 'utf8'));
-  assert.ok(binding.name.checkString(expected, 'utf16'));
-  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
-  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
-
-  const str1 = binding.name.createString('utf8');
-  assert.strictEqual(str1, expected);
-  assert.ok(binding.name.checkString(str1, 'utf8'));
-  assert.ok(binding.name.checkString(str1, 'utf16'));
-
-  const substr1 = binding.name.createString('utf8', 3);
-  assert.strictEqual(substr1, expected.substr(0, 3));
-  assert.ok(binding.name.checkString(substr1, 'utf8', 3));
-  assert.ok(binding.name.checkString(substr1, 'utf16', 3));
-
-  const str2 = binding.name.createString('utf16');
-  assert.strictEqual(str1, expected);
-  assert.ok(binding.name.checkString(str2, 'utf8'));
-  assert.ok(binding.name.checkString(str2, 'utf16'));
-
-  const substr2 = binding.name.createString('utf16', 3);
-  assert.strictEqual(substr1, expected.substr(0, 3));
-  assert.ok(binding.name.checkString(substr2, 'utf8', 3));
-  assert.ok(binding.name.checkString(substr2, 'utf16', 3));
-
-  assert.ok(binding.name.checkSymbol(Symbol()));
-  assert.ok(binding.name.checkSymbol(Symbol('test')));
-
-  const sym1 = binding.name.createSymbol();
-  assert.strictEqual(typeof sym1, 'symbol');
-  assert.ok(binding.name.checkSymbol(sym1));
-
-  const sym2 = binding.name.createSymbol('test');
-  assert.strictEqual(typeof sym2, 'symbol');
-  assert.ok(binding.name.checkSymbol(sym1));
-
-  // Check for off-by-one errors which might only appear for strings of certain sizes,
-  // due to how std::string increments its capacity in chunks.
-  const longString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-  for (let i = 10; i <= longString.length; i++) {
-    const str = longString.substr(0, i);
-    assert.strictEqual(binding.name.echoString(str, 'utf8'), str);
-    assert.strictEqual(binding.name.echoString(str, 'utf16'), str);
-  }
-}

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

@@ -1,14 +0,0 @@
-// Makes sure that child processes are spawned appropriately.
-exports.spawnSync = function(command, args, options) {
-  if (require('../index').needsFlag) {
-    args.splice(0, 0, '--napi-modules');
-  }
-  return require('child_process').spawnSync(command, args, options);
-};
-
-exports.spawn = function(command, args, options) {
-  if (require('../index').needsFlag) {
-    args.splice(0, 0, '--napi-modules');
-  }
-  return require('child_process').spawn(command, args, options);
-};

package/vendor/node-addon-api/test/object/delete_property.cc

@@ -1,38 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-Value DeletePropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Number key = info[1].As<Number>();
-  return Boolean::New(info.Env(), MaybeUnwrap(obj.Delete(key.Uint32Value())));
-}
-
-Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(obj.Delete(static_cast<napi_value>(key)), false));
-}
-
-Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Delete(key), false));
-}
-
-Value DeletePropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(
-      info.Env(), MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value().c_str()), false));
-}
-
-Value DeletePropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(info.Env(),
-                      MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));
-}