koffi 0.9.33 → 0.9.34

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

@@ -1,237 +0,0 @@
-#include <condition_variable>
-#include <cstdlib>
-#include <mutex>
-#include <thread>
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct TestData {
-  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)){};
-
-  // Native Promise returned to JavaScript
-  Promise::Deferred deferred;
-
-  // List of threads created for test. This list only ever accessed via main
-  // thread.
-  std::vector<std::thread> threads = {};
-
-  // These variables are only accessed from the main thread.
-  bool mainWantsRelease = false;
-  size_t expected_calls = 0;
-
-  static void CallJs(Napi::Env env,
-                     Function callback,
-                     TestData* testData,
-                     double* data) {
-    // This lambda runs on the main thread so it's OK to access the variables
-    // `expected_calls` and `mainWantsRelease`.
-    testData->expected_calls--;
-    if (testData->expected_calls == 0 && testData->mainWantsRelease)
-      testData->tsfn.Release();
-    callback.Call({Number::New(env, *data)});
-    delete data;
-  }
-
-  TypedThreadSafeFunction<TestData, double, CallJs> tsfn;
-};
-
-using TSFN = TypedThreadSafeFunction<TestData, double, TestData::CallJs>;
-
-void FinalizerCallback(Napi::Env env, void*, TestData* finalizeData) {
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-/**
- * See threadsafe_function_sum.js for descriptions of the tests in this file
- */
-
-void entryWithTSFN(TSFN tsfn, int threadId) {
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-  tsfn.BlockingCall(new double(threadId));
-  tsfn.Release();
-}
-
-static Value TestWithTSFN(const CallbackInfo& info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  // We pass the test data to the Finalizer for cleanup. The finalizer is
-  // responsible for deleting this data as well.
-  TestData* testData = new TestData(Promise::Deferred::New(info.Env()));
-
-  TSFN tsfn =
-      TSFN::New(info.Env(),
-                cb,
-                "Test",
-                0,
-                threadCount,
-                testData,
-                std::function<decltype(FinalizerCallback)>(FinalizerCallback),
-                testData);
-
-  for (int i = 0; i < threadCount; ++i) {
-    // A copy of the ThreadSafeFunction will go to the thread entry point
-    testData->threads.push_back(std::thread(entryWithTSFN, tsfn, i));
-  }
-
-  return testData->deferred.Promise();
-}
-
-// Task instance created for each new std::thread
-class DelayedTSFNTask {
- public:
-  // Each instance has its own tsfn
-  TSFN tsfn;
-
-  // Thread-safety
-  std::mutex mtx;
-  std::condition_variable cv;
-
-  // Entry point for std::thread
-  void entryDelayedTSFN(int threadId) {
-    std::unique_lock<std::mutex> lk(mtx);
-    cv.wait(lk, [this] { return this->tsfn != nullptr; });
-    tsfn.BlockingCall(new double(threadId));
-    tsfn.Release();
-  };
-};
-
-struct TestDataDelayed : TestData {
-  TestDataDelayed(Promise::Deferred&& deferred)
-      : TestData(std::move(deferred)){};
-  ~TestDataDelayed() { taskInsts.clear(); };
-
-  // List of DelayedTSFNThread instances
-  std::vector<std::unique_ptr<DelayedTSFNTask>> taskInsts = {};
-};
-
-void FinalizerCallbackDelayed(Napi::Env env,
-                              TestDataDelayed* finalizeData,
-                              TestData*) {
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-static Value TestDelayedTSFN(const CallbackInfo& info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  TestDataDelayed* testData =
-      new TestDataDelayed(Promise::Deferred::New(info.Env()));
-
-  testData->tsfn = TSFN::New(info.Env(),
-                             cb,
-                             "Test",
-                             0,
-                             threadCount,
-                             testData,
-                             std::function<decltype(FinalizerCallbackDelayed)>(
-                                 FinalizerCallbackDelayed),
-                             testData);
-
-  for (int i = 0; i < threadCount; ++i) {
-    testData->taskInsts.push_back(
-        std::unique_ptr<DelayedTSFNTask>(new DelayedTSFNTask()));
-    testData->threads.push_back(std::thread(&DelayedTSFNTask::entryDelayedTSFN,
-                                            testData->taskInsts.back().get(),
-                                            i));
-  }
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-
-  for (auto& task : testData->taskInsts) {
-    std::lock_guard<std::mutex> lk(task->mtx);
-    task->tsfn = testData->tsfn;
-    task->cv.notify_all();
-  }
-
-  return testData->deferred.Promise();
-}
-
-void AcquireFinalizerCallback(Napi::Env env,
-                              TestData* finalizeData,
-                              TestData* context) {
-  (void)context;
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-void entryAcquire(TSFN tsfn, int threadId) {
-  tsfn.Acquire();
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-  tsfn.BlockingCall(new double(threadId));
-  tsfn.Release();
-}
-
-static Value CreateThread(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  // Counting expected calls like this only works because on the JS side this
-  // binding is called from a synchronous loop. This means the main loop has no
-  // chance to run the tsfn JS callback before we've counted how many threads
-  // the JS intends to create.
-  testData->expected_calls++;
-  TSFN tsfn = testData->tsfn;
-  int threadId = testData->threads.size();
-  // A copy of the ThreadSafeFunction will go to the thread entry point
-  testData->threads.push_back(std::thread(entryAcquire, tsfn, threadId));
-  return Number::New(info.Env(), threadId);
-}
-
-static Value StopThreads(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  testData->mainWantsRelease = true;
-  return info.Env().Undefined();
-}
-
-static Value TestAcquire(const CallbackInfo& info) {
-  Function cb = info[0].As<Function>();
-  Napi::Env env = info.Env();
-
-  // We pass the test data to the Finalizer for cleanup. The finalizer is
-  // responsible for deleting this data as well.
-  TestData* testData = new TestData(Promise::Deferred::New(info.Env()));
-
-  testData->tsfn = TSFN::New(env,
-                             cb,
-                             "Test",
-                             0,
-                             1,
-                             testData,
-                             std::function<decltype(AcquireFinalizerCallback)>(
-                                 AcquireFinalizerCallback),
-                             testData);
-
-  Object result = Object::New(env);
-  result["createThread"] =
-      Function::New(env, CreateThread, "createThread", testData);
-  result["stopThreads"] =
-      Function::New(env, StopThreads, "stopThreads", testData);
-  result["promise"] = testData->deferred.Promise();
-
-  return result;
-}
-}  // namespace
-
-Object InitTypedThreadSafeFunctionSum(Env env) {
-  Object exports = Object::New(env);
-  exports["testDelayedTSFN"] = Function::New(env, TestDelayedTSFN);
-  exports["testWithTSFN"] = Function::New(env, TestWithTSFN);
-  exports["testAcquire"] = Function::New(env, TestAcquire);
-  return exports;
-}
-
-#endif

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_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.typed_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.typed_threadsafe_function_sum.testDelayedTSFN)
-    .then(() => check(binding.typed_threadsafe_function_sum.testWithTSFN))
-    .then(() => checkAcquire());
-}

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

@@ -1,53 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-using TSFN = TypedThreadSafeFunction<>;
-using ContextType = std::nullptr_t;
-using FinalizerDataType = void;
-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>();
-  TSFN* tsfn = new TSFN;
-
-  *tsfn = TSFN::New(
-      info.Env(),
-      cb,
-      resource,
-      "Test",
-      1,
-      1,
-      nullptr,
-      [tsfn](Napi::Env /* env */, FinalizerDataType*, ContextType*) {
-        delete tsfn;
-      },
-      static_cast<FinalizerDataType*>(nullptr));
-
-  tsfn->BlockingCall();
-
-  setTimeout.Call(
-      global,
-      {Function::New(
-           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
-       Number::New(env, 100)});
-
-  return info.Env().Undefined();
-}
-
-}  // namespace
-
-Object InitTypedThreadSafeFunctionUnref(Env env) {
-  Object exports = Object::New(env);
-  exports["testUnref"] = Function::New(env, TestUnref);
-  return exports;
-}
-
-#endif

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_unref.js

@@ -1,53 +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.
- */
-
-if (isMainProcess) {
-  module.exports = require('../common').runTestWithBindingPath(test);
-} else {
-  test(process.argv[2]);
-}
-
-function test(bindingFile) {
-  if (isMainProcess) {
-    // Main process
-    return new Promise((resolve, reject) => {
-      const child = require('../napi_child').spawn(process.argv[0], [
-        '--expose-gc', __filename, bindingFile
-      ], { 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();
-      });
-    });
-  } else {
-    // Child process
-    const binding = require(bindingFile);
-    binding.typed_threadsafe_function_unref.testUnref({}, () => { });
-  }
-}

package/vendor/node-addon-api/test/typedarray-bigint.js

@@ -1,58 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  [
-    ['bigint64', BigInt64Array],
-    ['biguint64', BigUint64Array],
-  ].forEach(([type, Constructor]) => {
-    try {
-      const length = 4;
-      const t = binding.typedarray.createTypedArray(type, length);
-      assert.ok(t instanceof Constructor);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-
-      t[3] = 11n;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
-      binding.typedarray.setTypedArrayElement(t, 3, 22n);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
-      assert.strictEqual(t[3], 22n);
-
-      const b = binding.typedarray.getTypedArrayBuffer(t);
-      assert.ok(b instanceof ArrayBuffer);
-    } catch (e) {
-      console.log(type, Constructor);
-      throw e;
-    }
-
-    try {
-      const length = 4;
-      const offset = 8;
-      const b = new ArrayBuffer(offset + 64 * 4);
-
-      const t = binding.typedarray.createTypedArray(type, length, b, offset);
-      assert.ok(t instanceof Constructor);
-      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
-      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
-
-      t[3] = 11n;
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
-      binding.typedarray.setTypedArrayElement(t, 3, 22n);
-      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
-      assert.strictEqual(t[3], 22n);
-
-      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
-    } catch (e) {
-      console.log(type, Constructor);
-      throw e;
-    }
-  });
-
-  assert.throws(() => {
-    binding.typedarray.createInvalidTypedArray();
-  }, /Invalid (pointer passed as )?argument/);
-}

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

@@ -1,216 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-#if defined(NAPI_HAS_CONSTEXPR)
-#define NAPI_TYPEDARRAY_NEW(className, env, length, type) className::New(env, length)
-#define NAPI_TYPEDARRAY_NEW_BUFFER(className, env, length, buffer, bufferOffset, type) \
-  className::New(env, length, buffer, bufferOffset)
-#else
-#define NAPI_TYPEDARRAY_NEW(className, env, length, type) className::New(env, length, type)
-#define NAPI_TYPEDARRAY_NEW_BUFFER(className, env, length, buffer, bufferOffset, type) \
-  className::New(env, length, buffer, bufferOffset, type)
-#endif
-
-namespace {
-
-Value CreateTypedArray(const CallbackInfo& info) {
-  std::string arrayType = info[0].As<String>();
-  size_t length = info[1].As<Number>().Uint32Value();
-  ArrayBuffer buffer = info[2].As<ArrayBuffer>();
-  size_t bufferOffset = info[3].IsUndefined() ? 0 : info[3].As<Number>().Uint32Value();
-
-  if (arrayType == "int8") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Int8Array, info.Env(), length, napi_int8_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_int8_array);
-  } else if (arrayType == "uint8") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Uint8Array, info.Env(), length, napi_uint8_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Uint8Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_uint8_array);
-  } else if (arrayType == "uint8_clamped") {
-    return buffer.IsUndefined() ?
-      Uint8Array::New(info.Env(), length, napi_uint8_clamped_array) :
-      Uint8Array::New(info.Env(), length, buffer, bufferOffset, napi_uint8_clamped_array);
-  } else if (arrayType == "int16") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Int16Array, info.Env(), length, napi_int16_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Int16Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_int16_array);
-  } else if (arrayType == "uint16") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Uint16Array, info.Env(), length, napi_uint16_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Uint16Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_uint16_array);
-  } else if (arrayType == "int32") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Int32Array, info.Env(), length, napi_int32_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Int32Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_int32_array);
-  } else if (arrayType == "uint32") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Uint32Array, info.Env(), length, napi_uint32_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Uint32Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_uint32_array);
-  } else if (arrayType == "float32") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Float32Array, info.Env(), length, napi_float32_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Float32Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_float32_array);
-  } else if (arrayType == "float64") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(Float64Array, info.Env(), length, napi_float64_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(Float64Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_float64_array);
-#if (NAPI_VERSION > 5)
-  } else if (arrayType == "bigint64") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(BigInt64Array, info.Env(), length, napi_bigint64_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(BigInt64Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_bigint64_array);
-  } else if (arrayType == "biguint64") {
-    return buffer.IsUndefined() ?
-      NAPI_TYPEDARRAY_NEW(BigUint64Array, info.Env(), length, napi_biguint64_array) :
-      NAPI_TYPEDARRAY_NEW_BUFFER(BigUint64Array, info.Env(), length, buffer, bufferOffset,
-                                 napi_biguint64_array);
-#endif
-  } else {
-    Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateInvalidTypedArray(const CallbackInfo& info) {
-  return NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array, info.Env(), 1, ArrayBuffer(), 0, napi_int8_array);
-}
-
-Value GetTypedArrayType(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  switch (array.TypedArrayType()) {
-    case napi_int8_array: return String::New(info.Env(), "int8");
-    case napi_uint8_array: return String::New(info.Env(), "uint8");
-    case napi_uint8_clamped_array: return String::New(info.Env(), "uint8_clamped");
-    case napi_int16_array: return String::New(info.Env(), "int16");
-    case napi_uint16_array: return String::New(info.Env(), "uint16");
-    case napi_int32_array: return String::New(info.Env(), "int32");
-    case napi_uint32_array: return String::New(info.Env(), "uint32");
-    case napi_float32_array: return String::New(info.Env(), "float32");
-    case napi_float64_array: return String::New(info.Env(), "float64");
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array: return String::New(info.Env(), "bigint64");
-    case napi_biguint64_array: return String::New(info.Env(), "biguint64");
-#endif
-    default: return String::New(info.Env(), "invalid");
-  }
-}
-
-Value GetTypedArrayLength(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return Number::New(info.Env(), static_cast<double>(array.ElementLength()));
-}
-
-Value GetTypedArrayBuffer(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  return array.ArrayBuffer();
-}
-
-Value GetTypedArrayElement(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      return Number::New(info.Env(), array.As<Int8Array>()[index]);
-    case napi_uint8_array:
-      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
-    case napi_uint8_clamped_array:
-      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
-    case napi_int16_array:
-      return Number::New(info.Env(), array.As<Int16Array>()[index]);
-    case napi_uint16_array:
-      return Number::New(info.Env(), array.As<Uint16Array>()[index]);
-    case napi_int32_array:
-      return Number::New(info.Env(), array.As<Int32Array>()[index]);
-    case napi_uint32_array:
-      return Number::New(info.Env(), array.As<Uint32Array>()[index]);
-    case napi_float32_array:
-      return Number::New(info.Env(), array.As<Float32Array>()[index]);
-    case napi_float64_array:
-      return Number::New(info.Env(), array.As<Float64Array>()[index]);
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array:
-      return BigInt::New(info.Env(), array.As<BigInt64Array>()[index]);
-    case napi_biguint64_array:
-      return BigInt::New(info.Env(), array.As<BigUint64Array>()[index]);
-#endif
-    default:
-      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
-      return Value();
-  }
-}
-
-void SetTypedArrayElement(const CallbackInfo& info) {
-  TypedArray array = info[0].As<TypedArray>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  Number value = info[2].As<Number>();
-  switch (array.TypedArrayType()) {
-    case napi_int8_array:
-      array.As<Int8Array>()[index] = static_cast<int8_t>(value.Int32Value());
-      break;
-    case napi_uint8_array:
-      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
-      break;
-    case napi_uint8_clamped_array:
-      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
-      break;
-    case napi_int16_array:
-      array.As<Int16Array>()[index] = static_cast<int16_t>(value.Int32Value());
-      break;
-    case napi_uint16_array:
-      array.As<Uint16Array>()[index] = static_cast<uint16_t>(value.Uint32Value());
-      break;
-    case napi_int32_array:
-      array.As<Int32Array>()[index] = value.Int32Value();
-      break;
-    case napi_uint32_array:
-      array.As<Uint32Array>()[index] = value.Uint32Value();
-      break;
-    case napi_float32_array:
-      array.As<Float32Array>()[index] = value.FloatValue();
-      break;
-    case napi_float64_array:
-      array.As<Float64Array>()[index] = value.DoubleValue();
-      break;
-#if (NAPI_VERSION > 5)
-    case napi_bigint64_array: {
-      bool lossless;
-      array.As<BigInt64Array>()[index] = value.As<BigInt>().Int64Value(&lossless);
-      break;
-    }
-    case napi_biguint64_array: {
-      bool lossless;
-      array.As<BigUint64Array>()[index] = value.As<BigInt>().Uint64Value(&lossless);
-      break;
-    }
-#endif
-    default:
-      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
-  }
-}
-
-} // end anonymous namespace
-
-Object InitTypedArray(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createTypedArray"] = Function::New(env, CreateTypedArray);
-  exports["createInvalidTypedArray"] = Function::New(env, CreateInvalidTypedArray);
-  exports["getTypedArrayType"] = Function::New(env, GetTypedArrayType);
-  exports["getTypedArrayLength"] = Function::New(env, GetTypedArrayLength);
-  exports["getTypedArrayBuffer"] = Function::New(env, GetTypedArrayBuffer);
-  exports["getTypedArrayElement"] = Function::New(env, GetTypedArrayElement);
-  exports["setTypedArrayElement"] = Function::New(env, SetTypedArrayElement);
-
-  return exports;
-}