koffi 2.16.0-beta.2 → 2.16.0

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_sum.js

@@ -1,59 +0,0 @@
-'use strict';
-const assert = require('assert');
-
-/**
- *
- * ThreadSafeFunction Tests: Thread Id Sums
- *
- * Every native C++ function that utilizes the TSFN will call the registered
- * callback with the thread id. Passing Array.prototype.push with a bound array
- * will push the thread id to the array. Therefore, starting `N` threads, we
- * will expect the sum of all elements in the array to be `(N-1) * (N) / 2` (as
- * thread IDs are 0-based)
- *
- * We check different methods of passing a ThreadSafeFunction around multiple
- * threads:
- *  - `testWithTSFN`: The main thread creates the TSFN. Then, it creates
- *    threads, passing the TSFN at thread construction. The number of threads is
- *    static (known at TSFN creation).
- *  - `testDelayedTSFN`: The main thread creates threads, passing a promise to a
- *    TSFN at construction. Then, it creates the TSFN, and resolves each
- *    threads' promise. The number of threads is static.
- *  - `testAcquire`: The native binding returns a function to start a new. A
- *    call to this function will return `false` once `N` calls have been made.
- *    Each thread will acquire its own use of the TSFN, call it, and then
- *    release.
- */
-
-const THREAD_COUNT = 5;
-const EXPECTED_SUM = (THREAD_COUNT - 1) * (THREAD_COUNT) / 2;
-
-module.exports = require('../common').runTest(test);
-
-/** @param {number[]} N */
-const sum = (N) => N.reduce((sum, n) => sum + n, 0);
-
-function test (binding) {
-  async function check (bindingFunction) {
-    const calls = [];
-    const result = await bindingFunction(THREAD_COUNT, Array.prototype.push.bind(calls));
-    assert.ok(result);
-    assert.equal(sum(calls), EXPECTED_SUM);
-  }
-
-  async function checkAcquire () {
-    const calls = [];
-    const { promise, createThread, stopThreads } = binding.threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
-    for (let i = 0; i < THREAD_COUNT; i++) {
-      createThread();
-    }
-    stopThreads();
-    const result = await promise;
-    assert.ok(result);
-    assert.equal(sum(calls), EXPECTED_SUM);
-  }
-
-  return check(binding.threadsafe_function_sum.testDelayedTSFN)
-    .then(() => check(binding.threadsafe_function_sum.testWithTSFN))
-    .then(() => checkAcquire());
-}

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_unref.cc

@@ -1,55 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-static Value TestUnref(const CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Object global = env.Global();
-  Object resource = info[0].As<Object>();
-  Function cb = info[1].As<Function>();
-  Function setTimeout = MaybeUnwrap(global.Get("setTimeout")).As<Function>();
-  ThreadSafeFunction* tsfn = new ThreadSafeFunction;
-
-  *tsfn = ThreadSafeFunction::New(
-      info.Env(), cb, resource, "Test", 1, 1, [tsfn](Napi::Env /* env */) {
-        delete tsfn;
-      });
-
-  tsfn->BlockingCall();
-
-  setTimeout.Call(
-      global,
-      {Function::New(
-           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
-       Number::New(env, 100)});
-
-  return info.Env().Undefined();
-}
-
-static Value TestRef(const CallbackInfo& info) {
-  Function cb = info[1].As<Function>();
-
-  auto tsfn = ThreadSafeFunction::New(info.Env(), cb, "testRes", 1, 1);
-
-  tsfn.BlockingCall();
-  tsfn.Unref(info.Env());
-  tsfn.Ref(info.Env());
-
-  return info.Env().Undefined();
-}
-
-}  // namespace
-
-Object InitThreadSafeFunctionUnref(Env env) {
-  Object exports = Object::New(env);
-  exports["testUnref"] = Function::New(env, TestUnref);
-  exports["testRef"] = Function::New(env, TestRef);
-  return exports;
-}
-
-#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_unref.js

@@ -1,98 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-const isMainProcess = process.argv[1] !== __filename;
-
-/**
- * In order to test that the event loop exits even with an active TSFN, we need
- * to spawn a new process for the test.
- *   - Main process: spawns new node instance, executing this script
- *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
- *
- * Main process should expect child process to exit.
- *
- * We also added a new test case for `Ref`. The idea being, if a TSFN is active, the event loop that it belongs to should not exit
- * Our setup is similar to the test for the `Unref` case, with the difference being now we are expecting the child process to hang
- */
-
-if (isMainProcess) {
-  module.exports = require('../common').runTestWithBindingPath(test);
-} else {
-  const isTestingRef = (process.argv[3] === 'true');
-
-  if (isTestingRef) {
-    execTSFNRefTest(process.argv[2]);
-  } else {
-    execTSFNUnrefTest(process.argv[2]);
-  }
-}
-
-function testUnRefCallback (resolve, reject, bindingFile) {
-  const child = require('../napi_child').spawn(process.argv[0], [
-    '--expose-gc', __filename, bindingFile, false
-  ], { stdio: 'inherit' });
-
-  let timeout = setTimeout(function () {
-    child.kill();
-    timeout = 0;
-    reject(new Error('Expected child to die'));
-  }, 5000);
-
-  child.on('error', (err) => {
-    clearTimeout(timeout);
-    timeout = 0;
-    reject(new Error(err));
-  });
-
-  child.on('close', (code) => {
-    if (timeout) clearTimeout(timeout);
-    assert.strictEqual(code, 0, 'Expected return value 0');
-    resolve();
-  });
-}
-
-function testRefCallback (resolve, reject, bindingFile) {
-  const child = require('../napi_child').spawn(process.argv[0], [
-    '--expose-gc', __filename, bindingFile, true
-  ], { stdio: 'inherit' });
-
-  let timeout = setTimeout(function () {
-    child.kill();
-    timeout = 0;
-    resolve();
-  }, 1000);
-
-  child.on('error', (err) => {
-    clearTimeout(timeout);
-    timeout = 0;
-    reject(new Error(err));
-  });
-
-  child.on('close', (code) => {
-    if (timeout) clearTimeout(timeout);
-
-    reject(new Error('We expected Child to hang'));
-  });
-}
-
-function test (bindingFile) {
-  // Main process
-  return new Promise((resolve, reject) => {
-    testUnRefCallback(resolve, reject, bindingFile);
-  }).then(() => {
-    return new Promise((resolve, reject) => {
-      testRefCallback(resolve, reject, bindingFile);
-    });
-  });
-}
-
-function execTSFNUnrefTest (bindingFile) {
-  const binding = require(bindingFile);
-  binding.threadsafe_function_unref.testUnref({}, () => { });
-}
-
-function execTSFNRefTest (bindingFile) {
-  const binding = require(bindingFile);
-  binding.threadsafe_function_unref.testRef({}, () => { });
-}

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

@@ -1,127 +0,0 @@
-#include <napi.h>
-
-// The formulaic comment below should accompany any code that results in an
-// internal piece of heap data getting created, because each such piece of heap
-// data must be attached to an object by way of a deleter which gets called when
-// the object gets garbage-collected.
-//
-// At the very least, you can add a fprintf(stderr, ...) to the deleter in
-// napi-inl.h and then count the number of times the deleter prints by running
-// node --expose-gc test/thunking_manual.js and counting the number of prints
-// between the two rows of dashes. That number should coincide with the number
-// of formulaic comments below.
-//
-// Note that currently this result can only be achieved with node-chakracore,
-// because V8 does not garbage-collect classes.
-
-static Napi::Value TestMethod(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static void TestSetter(const Napi::CallbackInfo& /*info*/) {}
-
-class TestClass : public Napi::ObjectWrap<TestClass> {
- public:
-  TestClass(const Napi::CallbackInfo& info) : ObjectWrap<TestClass>(info) {}
-  static Napi::Value TestClassStaticMethod(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  static void TestClassStaticVoidMethod(const Napi::CallbackInfo& /*info*/) {}
-
-  Napi::Value TestClassInstanceMethod(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  void TestClassInstanceVoidMethod(const Napi::CallbackInfo& /*info*/) {}
-
-  Napi::Value TestClassInstanceGetter(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  void TestClassInstanceSetter(const Napi::CallbackInfo& /*info*/,
-                               const Napi::Value& /*new_value*/) {}
-
-  static Napi::Function NewClass(Napi::Env env) {
-    return DefineClass(
-        env,
-        "TestClass",
-        {// Make sure to check that the deleter gets called.
-         StaticMethod("staticMethod", TestClassStaticMethod),
-         // Make sure to check that the deleter gets called.
-         StaticMethod("staticVoidMethod", TestClassStaticVoidMethod),
-         // Make sure to check that the deleter gets called.
-         StaticMethod(Napi::Symbol::New(env, "staticMethod"),
-                      TestClassStaticMethod),
-         // Make sure to check that the deleter gets called.
-         StaticMethod(Napi::Symbol::New(env, "staticVoidMethod"),
-                      TestClassStaticVoidMethod),
-         // Make sure to check that the deleter gets called.
-         InstanceMethod("instanceMethod", &TestClass::TestClassInstanceMethod),
-         // Make sure to check that the deleter gets called.
-         InstanceMethod("instanceVoidMethod",
-                        &TestClass::TestClassInstanceVoidMethod),
-         // Make sure to check that the deleter gets called.
-         InstanceMethod(Napi::Symbol::New(env, "instanceMethod"),
-                        &TestClass::TestClassInstanceMethod),
-         // Make sure to check that the deleter gets called.
-         InstanceMethod(Napi::Symbol::New(env, "instanceVoidMethod"),
-                        &TestClass::TestClassInstanceVoidMethod),
-         // Make sure to check that the deleter gets called.
-         InstanceAccessor("instanceAccessor",
-                          &TestClass::TestClassInstanceGetter,
-                          &TestClass::TestClassInstanceSetter)});
-  }
-};
-
-static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Object item = Napi::Object::New(env);
-
-  // Make sure to check that the deleter gets called.
-  item["testMethod"] = Napi::Function::New(env, TestMethod, "testMethod");
-
-  item.DefineProperties({
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(env, item, "accessor_1", TestGetter),
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(
-          env, item, std::string("accessor_1_std_string"), TestGetter),
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(
-          env,
-          item,
-          Napi::String::New(info.Env(), "accessor_1_js_string"),
-          TestGetter),
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(
-          env, item, "accessor_2", TestGetter, TestSetter),
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(env,
-                                         item,
-                                         std::string("accessor_2_std_string"),
-                                         TestGetter,
-                                         TestSetter),
-      // Make sure to check that the deleter gets called.
-      Napi::PropertyDescriptor::Accessor(
-          env,
-          item,
-          Napi::String::New(env, "accessor_2_js_string"),
-          TestGetter,
-          TestSetter),
-      Napi::PropertyDescriptor::Value("TestClass", TestClass::NewClass(env)),
-  });
-
-  return item;
-}
-
-Napi::Object InitThunkingManual(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  exports["createTestObject"] =
-      Napi::Function::New(env, CreateTestObject, "createTestObject");
-  return exports;
-}

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

@@ -1,16 +0,0 @@
-// Flags: --expose-gc
-'use strict';
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  console.log('Thunking: Performing initial GC');
-  global.gc();
-  console.log('Thunking: Creating test object');
-  let object = binding.thunking_manual.createTestObject();
-  // eslint-disable-next-line no-unused-vars
-  object = null;
-  console.log('Thunking: About to GC\n--------');
-  global.gc();
-  console.log('--------\nThunking: GC complete');
-}

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

@@ -1,66 +0,0 @@
-#include "napi.h"
-
-#if (NAPI_VERSION > 7)
-
-using namespace Napi;
-
-static const napi_type_tag type_tags[5] = {
-    {0xdaf987b3cc62481a, 0xb745b0497f299531},
-    {0xbb7936c374084d9b, 0xa9548d0762eeedb9},
-    {0xa5ed9ce2e4c00c38, 0},
-    {0, 0},
-    {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a},
-};
-
-template <TypeTaggable Factory(Env), typename NodeApiClass>
-class TestTypeTaggable {
- public:
-  static Value TypeTaggedInstance(const CallbackInfo& info) {
-    TypeTaggable instance = Factory(info.Env());
-    uint32_t type_index = info[0].As<Number>().Int32Value();
-
-    instance.TypeTag(&type_tags[type_index]);
-
-    return instance;
-  }
-
-  static Value CheckTypeTag(const CallbackInfo& info) {
-    uint32_t type_index = info[0].As<Number>().Int32Value();
-    TypeTaggable instance = info[1].UnsafeAs<NodeApiClass>();
-
-    return Boolean::New(info.Env(),
-                        instance.CheckTypeTag(&type_tags[type_index]));
-  }
-};
-
-TypeTaggable ObjectFactory(Env env) {
-  return Object::New(env);
-}
-
-TypeTaggable ExternalFactory(Env env) {
-  // External does not accept a nullptr for its data.
-  return External<void>::New(env, reinterpret_cast<void*>(0x1));
-}
-
-using TestObject = TestTypeTaggable<ObjectFactory, Object>;
-using TestExternal = TestTypeTaggable<ExternalFactory, External<void>>;
-
-Object InitTypeTaggable(Env env) {
-  Object exports = Object::New(env);
-
-  Object external = Object::New(env);
-  exports["external"] = external;
-  external["checkTypeTag"] = Function::New(env, &TestExternal::CheckTypeTag);
-  external["typeTaggedInstance"] =
-      Function::New(env, &TestExternal::TypeTaggedInstance);
-
-  Object object = Object::New(env);
-  exports["object"] = object;
-  object["checkTypeTag"] = Function::New(env, &TestObject::CheckTypeTag);
-  object["typeTaggedInstance"] =
-      Function::New(env, &TestObject::TypeTaggedInstance);
-
-  return exports;
-}
-
-#endif

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

@@ -1,59 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function testTypeTaggable ({ typeTaggedInstance, checkTypeTag }) {
-  const obj1 = typeTaggedInstance(0);
-  const obj2 = typeTaggedInstance(1);
-
-  // Verify that type tags are correctly accepted.
-  assert.strictEqual(checkTypeTag(0, obj1), true);
-  assert.strictEqual(checkTypeTag(1, obj2), true);
-
-  // Verify that wrongly tagged objects are rejected.
-  assert.strictEqual(checkTypeTag(0, obj2), false);
-  assert.strictEqual(checkTypeTag(1, obj1), false);
-
-  // Verify that untagged objects are rejected.
-  assert.strictEqual(checkTypeTag(0, {}), false);
-  assert.strictEqual(checkTypeTag(1, {}), false);
-
-  // Node v14 and v16 have an issue checking type tags if the `upper` in
-  // `napi_type_tag` is 0, so these tests can only be performed on Node version
-  // >=18. See:
-  // - https://github.com/nodejs/node/issues/43786
-  // - https://github.com/nodejs/node/pull/43788
-  const nodeVersion = parseInt(process.versions.node.split('.')[0]);
-  if (nodeVersion < 18) {
-    return;
-  }
-
-  const obj3 = typeTaggedInstance(2);
-  const obj4 = typeTaggedInstance(3);
-
-  // Verify that untagged objects are rejected.
-  assert.strictEqual(checkTypeTag(0, {}), false);
-  assert.strictEqual(checkTypeTag(1, {}), false);
-
-  // Verify that type tags are correctly accepted.
-  assert.strictEqual(checkTypeTag(0, obj1), true);
-  assert.strictEqual(checkTypeTag(1, obj2), true);
-  assert.strictEqual(checkTypeTag(2, obj3), true);
-  assert.strictEqual(checkTypeTag(3, obj4), true);
-
-  // Verify that wrongly tagged objects are rejected.
-  assert.strictEqual(checkTypeTag(0, obj2), false);
-  assert.strictEqual(checkTypeTag(1, obj1), false);
-  assert.strictEqual(checkTypeTag(0, obj3), false);
-  assert.strictEqual(checkTypeTag(1, obj4), false);
-  assert.strictEqual(checkTypeTag(2, obj4), false);
-  assert.strictEqual(checkTypeTag(3, obj3), false);
-  assert.strictEqual(checkTypeTag(4, obj3), false);
-}
-
-function test (binding) {
-  testTypeTaggable(binding.type_taggable.external);
-  testTypeTaggable(binding.type_taggable.object);
-}

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

@@ -1,215 +0,0 @@
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-constexpr size_t ARRAY_LENGTH = 10;
-constexpr size_t MAX_QUEUE_SIZE = 2;
-
-static std::thread threads[2];
-
-static struct ThreadSafeFunctionInfo {
-  enum CallType { DEFAULT, BLOCKING, NON_BLOCKING } type;
-  bool abort;
-  bool startSecondary;
-  FunctionReference jsFinalizeCallback;
-  uint32_t maxQueueSize;
-  bool closeCalledFromJs;
-  std::mutex protect;
-  std::condition_variable signal;
-} tsfnInfo;
-
-static void TSFNCallJS(Env env,
-                       Function jsCallback,
-                       ThreadSafeFunctionInfo* /* context */,
-                       int* data) {
-  // A null environment signifies the threadsafe function has been finalized.
-  if (!(env == nullptr || jsCallback == nullptr)) {
-    // If called with no data
-    if (data == nullptr) {
-      jsCallback.Call({});
-    } else {
-      jsCallback.Call({Number::New(env, *data)});
-    }
-  }
-}
-
-using TSFN = TypedThreadSafeFunction<ThreadSafeFunctionInfo, int, TSFNCallJS>;
-static TSFN s_tsfn;
-
-// Thread data to transmit to JS
-static int ints[ARRAY_LENGTH];
-
-static void SecondaryThread() {
-  if (s_tsfn.Release() != napi_ok) {
-    Error::Fatal("TypedSecondaryThread", "ThreadSafeFunction.Release() failed");
-  }
-}
-
-// Source thread producing the data
-static void DataSourceThread() {
-  ThreadSafeFunctionInfo* info = s_tsfn.GetContext();
-
-  if (info->startSecondary) {
-    if (s_tsfn.Acquire() != napi_ok) {
-      Error::Fatal("TypedDataSourceThread",
-                   "ThreadSafeFunction.Acquire() failed");
-    }
-
-    threads[1] = std::thread(SecondaryThread);
-  }
-
-  bool queueWasFull = false;
-  bool queueWasClosing = false;
-  for (int index = ARRAY_LENGTH - 1; index > -1 && !queueWasClosing; index--) {
-    napi_status status = napi_generic_failure;
-
-    switch (info->type) {
-      case ThreadSafeFunctionInfo::DEFAULT:
-        status = s_tsfn.BlockingCall();
-        break;
-      case ThreadSafeFunctionInfo::BLOCKING:
-        status = s_tsfn.BlockingCall(&ints[index]);
-        break;
-      case ThreadSafeFunctionInfo::NON_BLOCKING:
-        status = s_tsfn.NonBlockingCall(&ints[index]);
-        break;
-    }
-
-    if (info->abort && info->type != ThreadSafeFunctionInfo::NON_BLOCKING) {
-      // Let's make this thread really busy to give the main thread a chance to
-      // abort / close.
-      std::unique_lock<std::mutex> lk(info->protect);
-      while (!info->closeCalledFromJs) {
-        info->signal.wait(lk);
-      }
-    }
-
-    switch (status) {
-      case napi_queue_full:
-        queueWasFull = true;
-        index++;
-        // fall through
-
-      case napi_ok:
-        continue;
-
-      case napi_closing:
-        queueWasClosing = true;
-        break;
-
-      default:
-        Error::Fatal("TypedDataSourceThread",
-                     "ThreadSafeFunction.*Call() failed");
-    }
-  }
-
-  if (info->type == ThreadSafeFunctionInfo::NON_BLOCKING && !queueWasFull) {
-    Error::Fatal("TypedDataSourceThread", "Queue was never full");
-  }
-
-  if (info->abort && !queueWasClosing) {
-    Error::Fatal("TypedDataSourceThread", "Queue was never closing");
-  }
-
-  if (!queueWasClosing && s_tsfn.Release() != napi_ok) {
-    Error::Fatal("TypedDataSourceThread",
-                 "ThreadSafeFunction.Release() failed");
-  }
-}
-
-static Value StopThread(const CallbackInfo& info) {
-  tsfnInfo.jsFinalizeCallback = Napi::Persistent(info[0].As<Function>());
-  bool abort = info[1].As<Boolean>();
-  if (abort) {
-    s_tsfn.Abort();
-  } else {
-    s_tsfn.Release();
-  }
-  {
-    std::lock_guard<std::mutex> _(tsfnInfo.protect);
-    tsfnInfo.closeCalledFromJs = true;
-    tsfnInfo.signal.notify_one();
-  }
-  return Value();
-}
-
-// Join the thread and inform JS that we're done.
-static void JoinTheThreads(Env /* env */,
-                           std::thread* theThreads,
-                           ThreadSafeFunctionInfo* info) {
-  theThreads[0].join();
-  if (info->startSecondary) {
-    theThreads[1].join();
-  }
-
-  info->jsFinalizeCallback.Call({});
-  info->jsFinalizeCallback.Reset();
-}
-
-static Value StartThreadInternal(const CallbackInfo& info,
-                                 ThreadSafeFunctionInfo::CallType type) {
-  tsfnInfo.type = type;
-  tsfnInfo.abort = info[1].As<Boolean>();
-  tsfnInfo.startSecondary = info[2].As<Boolean>();
-  tsfnInfo.maxQueueSize = info[3].As<Number>().Uint32Value();
-  tsfnInfo.closeCalledFromJs = false;
-
-  s_tsfn = TSFN::New(info.Env(),
-                     info[0].As<Function>(),
-                     Object::New(info.Env()),
-                     "Test",
-                     tsfnInfo.maxQueueSize,
-                     2,
-                     &tsfnInfo,
-                     JoinTheThreads,
-                     threads);
-
-  threads[0] = std::thread(DataSourceThread);
-
-  return Value();
-}
-
-static Value Release(const CallbackInfo& /* info */) {
-  if (s_tsfn.Release() != napi_ok) {
-    Error::Fatal("Release", "TypedThreadSafeFunction.Release() failed");
-  }
-  return Value();
-}
-
-static Value StartThread(const CallbackInfo& info) {
-  return StartThreadInternal(info, ThreadSafeFunctionInfo::BLOCKING);
-}
-
-static Value StartThreadNonblocking(const CallbackInfo& info) {
-  return StartThreadInternal(info, ThreadSafeFunctionInfo::NON_BLOCKING);
-}
-
-static Value StartThreadNoNative(const CallbackInfo& info) {
-  return StartThreadInternal(info, ThreadSafeFunctionInfo::DEFAULT);
-}
-
-Object InitTypedThreadSafeFunction(Env env) {
-  for (size_t index = 0; index < ARRAY_LENGTH; index++) {
-    ints[index] = index;
-  }
-
-  Object exports = Object::New(env);
-  exports["ARRAY_LENGTH"] = Number::New(env, ARRAY_LENGTH);
-  exports["MAX_QUEUE_SIZE"] = Number::New(env, MAX_QUEUE_SIZE);
-  exports["startThread"] = Function::New(env, StartThread);
-  exports["startThreadNoNative"] = Function::New(env, StartThreadNoNative);
-  exports["startThreadNonblocking"] =
-      Function::New(env, StartThreadNonblocking);
-  exports["stopThread"] = Function::New(env, StopThread);
-  exports["release"] = Function::New(env, Release);
-
-  return exports;
-}
-
-#endif