koffi 1.0.4 → 1.1.0-beta.1

package/test/misc.js

@@ -1,227 +0,0 @@
-#!/usr/bin/env node
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program. If not, see https://www.gnu.org/licenses/.
-
-const koffi = require('./build/koffi.node');
-const assert = require('assert');
-const path = require('path');
-
-const Pack1 = koffi.struct('Pack1', {
-    a: 'int'
-});
-const Pack2 = koffi.struct('Pack2', {
-    a: 'int',
-    b: 'int'
-});
-const Pack3 = koffi.struct('Pack3', {
-    a: 'int',
-    b: 'int',
-    c: 'int'
-});
-
-const Float2 = koffi.struct('Float2', {
-    a: 'float',
-    b: 'float'
-});
-const Float3 = koffi.struct('Float3', {
-    a: 'float',
-    b: 'float',
-    c: 'float'
-});
-
-const Double2 = koffi.struct('Double2', {
-    a: 'double',
-    b: 'double'
-});
-const Double3 = koffi.struct('Double3', {
-    a: 'double',
-    b: 'double',
-    c: 'double'
-});
-
-const BFG = koffi.struct('BFG', {
-    a: 'int8_t',
-    b: 'int64_t',
-    c: 'char',
-    d: 'string',
-    e: 'short',
-    inner: koffi.struct({
-        f: 'float',
-        g: 'double'
-    })
-});
-const PackedBFG = koffi.pack('PackedBFG', {
-    a: 'int8_t',
-    b: 'int64_t',
-    c: 'char',
-    d: 'string',
-    e: 'short',
-    inner: koffi.pack({
-        f: 'float',
-        g: 'double'
-    })
-});
-
-main();
-
-async function main() {
-    try {
-        await test();
-        console.log('Success!');
-    } catch (err) {
-        console.error(err);
-        process.exit(1);
-    }
-}
-
-async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
-    let lib = koffi.load(lib_filename);
-
-    const FillPack1 = lib.func('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
-    const RetPack1 = lib.func('RetPack1', Pack1, ['int']);
-    const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
-    const FillPack2 = lib.func('FillPack2', 'void', ['int', 'int', koffi.out(koffi.pointer(Pack2))]);
-    const RetPack2 = lib.func('RetPack2', Pack2, ['int', 'int']);
-    const AddPack2 = lib.fastcall('AddPack2', 'void', ['int', 'int', koffi.inout(koffi.pointer(Pack2))]);
-    const FillPack3 = lib.func('FillPack3', 'void', ['int', 'int', 'int', koffi.out(koffi.pointer(Pack3))]);
-    const RetPack3 = lib.func('RetPack3', Pack3, ['int', 'int', 'int']);
-    const AddPack3 = lib.fastcall('AddPack3', 'void', ['int', 'int', 'int', koffi.inout(koffi.pointer(Pack3))]);
-    const PackFloat2 = lib.func('Float2 PackFloat2(float a, float b, _Out_ Float2 *out)');
-    const PackFloat3 = lib.func('Float3 PackFloat3(float a, float b, float c, _Out_ Float3 *out)');
-    const PackDouble2 = lib.func('Double2 PackDouble2(double a, double b, _Out_ Double2 *out)');
-    const PackDouble3 = lib.func('Double3 PackDouble3(double a, double b, double c, _Out_ Double3 *out)');
-    const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
-    const ConcatenateToInt4 = lib.func('ConcatenateToInt4', 'int64_t', Array(12).fill('int32_t'));
-    const ConcatenateToInt8 = lib.func('ConcatenateToInt8', 'int64_t', Array(12).fill('int64_t'));
-    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
-    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
-    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
-    const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
-    const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
-    const ReturnBigString = process.platform == 'win32' ?
-                            lib.stdcall(1, 'string', ['string']) :
-                            lib.func('const char * __stdcall ReturnBigString(const char *str)');
-    const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
-    const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
-
-    // Simple tests with Pack1
-    {
-        let p = {};
-
-        FillPack1(777, p);
-        assert.deepEqual(p, { a: 777 });
-
-        let q = RetPack1(6);
-        assert.deepEqual(q, { a: 6 });
-
-        AddPack1(6, p);
-        assert.deepEqual(p, { a: 783 });
-    }
-
-    // Simple tests with Pack2
-    {
-        let p = {};
-
-        FillPack2(123, 456, p);
-        assert.deepEqual(p, { a: 123, b: 456 });
-
-        let q = RetPack2(6, 9);
-        assert.deepEqual(q, { a: 6, b: 9 });
-
-        AddPack2(6, 9, p);
-        assert.deepEqual(p, { a: 129, b: 465 });
-    }
-
-    // Simple tests with Pack3
-    {
-        let p = {};
-
-        FillPack3(1, 2, 3, p);
-        assert.deepEqual(p, { a: 1, b: 2, c: 3 });
-
-        let q = RetPack3(6, 9, -12);
-        assert.deepEqual(q, { a: 6, b: 9, c: -12 });
-
-        AddPack3(6, 9, -12, p);
-        assert.deepEqual(p, { a: 7, b: 11, c: -9 });
-    }
-
-    // HFA tests
-    {
-        let f2p = {};
-        let f2 = PackFloat2(1.5, 3.0, f2p);
-        assert.deepEqual(f2, { a: 1.5, b: 3.0 });
-        assert.deepEqual(f2, f2p);
-
-        let f3p = {};
-        let f3 = PackFloat3(20.0, 30.0, 40.0, f3p);
-        assert.deepEqual(f3, { a: 20.0, b: 30.0, c: 40.0 });
-        assert.deepEqual(f3, f3p);
-
-        let d2p = {};
-        let d2 = PackDouble2(1.0, 2.0, d2p);
-        assert.deepEqual(d2, { a: 1.0, b: 2.0 });
-        assert.deepEqual(d2, d2p);
-
-        let d3p = {};
-        let d3 = PackDouble3(0.5, 10.0, 5.0, d3p);
-        assert.deepEqual(d3, { a: 0.5, b: 10.0, c: 5.0 });
-        assert.deepEqual(d3, d3p);
-    }
-
-    // Many parameters
-    {
-        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-    }
-
-    // Big struct
-    {
-        let out = {};
-        let bfg = MakeBFG(out, 2, 7, '__Hello123456789++++foobarFOOBAR!__');
-        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
-        assert.deepEqual(out, bfg);
-    }
-
-    // Packed struct
-    {
-        let out = {};
-        let bfg = MakePackedBFG(2, 7, out, '__Hello123456789++++foobarFOOBAR!__');
-        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
-        assert.deepEqual(out, bfg);
-    }
-
-    // Big string
-    {
-        let str = 'fooBAR!'.repeat(1024 * 1024);
-        assert.equal(ReturnBigString(str), str);
-    }
-
-    // Variadic
-    {
-        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
-        assert.equal(str, 'foo 200 1.5 BAR');
-    }
-
-    // UTF-16LE strings
-    {
-        let str = Concat16('Hello ', 'World!');
-        assert.equal(str, 'Hello World!');
-    }
-}

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

@@ -1,4 +0,0 @@
-# Code of Conduct
-
-The Node.js Code of Conduct, which applies to this project, can be found at
-https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md.

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

@@ -1,93 +0,0 @@
-
-# Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
- (a) The contribution was created in whole or in part by me and I
-     have the right to submit it under the open source license
-     indicated in the file; or
-
- (b) The contribution is based upon previous work that, to the best
-     of my knowledge, is covered under an appropriate open source
-     license and I have the right under that license to submit that
-     work with modifications, whether created in whole or in part
-     by me, under the same open source license (unless I am
-     permitted to submit under a different license), as indicated
-     in the file; or
-
- (c) The contribution was provided directly to me by some other
-     person who certified (a), (b) or (c) and I have not modified
-     it.
-
- (d) I understand and agree that this project and the contribution
-     are public and that a record of the contribution (including all
-     personal information I submit with it, including my sign-off) is
-     maintained indefinitely and may be redistributed consistent with
-     this project or the open source license(s) involved.
-
-# **node-addon-api** Contribution Philosophy
-
-The **node-addon-api** team loves contributions. There are many ways in which you can
-contribute to **node-addon-api**:
-- Source code fixes
-- Additional tests
-- Documentation improvements
-- Joining the Node-API working group and participating in meetings
-
-## Source changes
-
-**node-addon-api** is meant to be a thin convenience wrapper around Node-API. With this
-in mind, contributions of any new APIs that wrap around a core Node-API API will
-be considered for merge. However, changes that wrap existing **node-addon-api**
-APIs are encouraged to instead be provided as an ecosystem module. The
-**node-addon-api** team is happy to link to a curated set of modules that build on
-top of **node-addon-api** if they have broad usefulness to the community and promote
-a recommended idiom or pattern.
-
-### Rationale
-
-The Node-API team considered a couple different approaches with regards to changes
-extending **node-addon-api**
-- Larger core module - Incorporate these helpers and patterns into **node-addon-api**
-- Extras package - Create a new package (strawman name '**node-addon-api**-extras')
-that contain utility classes and methods that help promote good patterns and
-idioms while writing native addons with **node-addon-api**.
-- Ecosystem - Encourage creation of a module ecosystem around **node-addon-api**
-where folks can build on top of it.
-
-#### Larger Core
-This is probably our simplest option in terms of immediate action needed. It
-would involve landing any open PRs against **node-addon-api**, and continuing to
-encourage folks to make PRs for utility helpers against the same repository.
-
-The downside of the approach is the following:
-- Less coherency for our API set
-- More maintenance burden on the Node-API WG core team.
-
-#### Extras Package
-This involves us spinning up a new package which contains the utility classes
-and methods. This has the benefit of having a separate module where helpers
-which make it easier to implement certain patterns and idioms for native addons
-easier.
-
-The downside of this approach is the following:
-- Potential for confusion - we'll need to provide clear documentation to help the
-community understand where a particular contribution should be directed to (what
-belongs in **node-addon-api** vs **node-addon-api-extras**)
-- Need to define the level of support/API guarantees
-- Unclear if the maintenance burden on the Node-API WG is reduced or not
-
-#### Ecosystem
-This doesn't require a ton of up-front work from the Node-API WG. Instead of
-accepting utility PRs into **node-addon-api** or creating and maintaining a new
-module, the WG will encourage the creation of an ecosystem of modules that
-build on top of **node-addon-api**, and provide some level of advertising for these
-modules (listing them out on the repository/wiki, using them in workshops/tutorials
-etc).
-
-The downside of this approach is the following:
-- Potential for lack of visibility - evangelism and education is hard, and module
-authors might not find right patterns and instead implement things themselves
-- There might be greater friction for the Node-API WG in evolving APIs since the
-ecosystem would have taken dependencies on the API shape of **node-addon-api**
-

package/vendor/node-addon-api/appveyor.yml

@@ -1,37 +0,0 @@
-environment:
-  # https://github.com/jasongin/nvs/blob/HEAD/doc/CI.md
-  NVS_VERSION: 1.4.2
-  matrix:
-    - NODEJS_VERSION: node/10
-    - NODEJS_VERSION: node/12
-    - NODEJS_VERSION: node/14
-    - NODEJS_VERSION: nightly
-
-os: Visual Studio 2017
-platform:
-  - x86
-  - x64
-
-install:
-  # nvs
-  - git clone --branch v%NVS_VERSION% --depth 1 https://github.com/jasongin/nvs %LOCALAPPDATA%\nvs
-  - set PATH=%LOCALAPPDATA%\nvs;%PATH%
-  - nvs --version
-  # node.js
-  - nvs add %NODEJS_VERSION%/%PLATFORM%
-  - nvs use %NODEJS_VERSION%/%PLATFORM%
-  - node --version
-  - node -p process.arch
-  - npm --version
-  # app
-  - npm install
-
-test_script:
-  - npm test
-
-build: off
-
-version: "{build}"
-
-cache:
-  - node_modules

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

@@ -1,47 +0,0 @@
-# Benchmarks
-
-## Running the benchmarks
-
-From the parent directory, run
-
-```bash
-npm run-script benchmark
-```
-
-The above script supports the following arguments:
-
-* `--benchmarks=...`: A semicolon-separated list of benchmark names. These names
-    will be mapped to file names in this directory by appending `.js`.
-
-## Adding benchmarks
-
-The steps below should be followed when adding new benchmarks.
-
-0. Decide on a name for the benchmark. This name will be used in several places.
-   This example will use the name `new_benchmark`.
-
-0. Create files `new_benchmark.cc` and `new_benchmark.js` in this directory.
-
-0. Copy an existing benchmark in `binding.gyp` and change the target name prefix
-    and the source file name to `new_benchmark`. This should result in two new
-    targets which look like this:
-
-    ```gyp
-      {
-        'target_name': 'new_benchmark',
-        'sources': [ 'new_benchmark.cc' ],
-        'includes': [ '../except.gypi' ],
-      },
-      {
-        'target_name': 'new_benchmark_noexcept',
-        'sources': [ 'new_benchmark.cc' ],
-        'includes': [ '../noexcept.gypi' ],
-      },
-    ```
-
-    There should always be a pair of targets: one bearing the name of the
-    benchmark and configured with C++ exceptions enabled, and one bearing the
-    same name followed by the suffix `_noexcept` and configured with C++
-    exceptions disabled. This will ensure that the benchmark can be written to
-    cover both the case where C++ exceptions are enabled and the case where they
-    are disabled.

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

@@ -1,25 +0,0 @@
-{
-  'target_defaults': { 'includes': ['../common.gypi'] },
-  'targets': [
-    {
-      'target_name': 'function_args',
-      'sources': [ 'function_args.cc' ],
-      'includes': [ '../except.gypi' ],
-    },
-    {
-      'target_name': 'function_args_noexcept',
-      'sources': [ 'function_args.cc' ],
-      'includes': [ '../noexcept.gypi' ],
-    },
-    {
-      'target_name': 'property_descriptor',
-      'sources': [ 'property_descriptor.cc' ],
-      'includes': [ '../except.gypi' ],
-    },
-    {
-      'target_name': 'property_descriptor_noexcept',
-      'sources': [ 'property_descriptor.cc' ],
-      'includes': [ '../noexcept.gypi' ],
-    },
-  ]
-}

package/vendor/node-addon-api/benchmark/function_args.cc

@@ -1,217 +0,0 @@
-#include "napi.h"
-
-static napi_value NoArgFunction_Core(napi_env env, napi_callback_info info) {
-  (void) env;
-  (void) info;
-  return nullptr;
-}
-
-static napi_value OneArgFunction_Core(napi_env env, napi_callback_info info) {
-  size_t argc = 1;
-  napi_value argv;
-  if (napi_get_cb_info(env, info, &argc, &argv, nullptr, nullptr) != napi_ok) {
-    return nullptr;
-  }
-  (void) argv;
-  return nullptr;
-}
-
-static napi_value TwoArgFunction_Core(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value argv[2];
-  if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok) {
-    return nullptr;
-  }
-  (void) argv[0];
-  (void) argv[1];
-  return nullptr;
-}
-
-static napi_value ThreeArgFunction_Core(napi_env env, napi_callback_info info) {
-  size_t argc = 3;
-  napi_value argv[3];
-  if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok) {
-    return nullptr;
-  }
-  (void) argv[0];
-  (void) argv[1];
-  (void) argv[2];
-  return nullptr;
-}
-
-static napi_value FourArgFunction_Core(napi_env env, napi_callback_info info) {
-  size_t argc = 4;
-  napi_value argv[4];
-  if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok) {
-    return nullptr;
-  }
-  (void) argv[0];
-  (void) argv[1];
-  (void) argv[2];
-  (void) argv[3];
-  return nullptr;
-}
-
-static void NoArgFunction(const Napi::CallbackInfo& info) {
-  (void) info;
-}
-
-static void OneArgFunction(const Napi::CallbackInfo& info) {
-  Napi::Value argv0 = info[0]; (void) argv0;
-}
-
-static void TwoArgFunction(const Napi::CallbackInfo& info) {
-  Napi::Value argv0 = info[0]; (void) argv0;
-  Napi::Value argv1 = info[1]; (void) argv1;
-}
-
-static void ThreeArgFunction(const Napi::CallbackInfo& info) {
-  Napi::Value argv0 = info[0]; (void) argv0;
-  Napi::Value argv1 = info[1]; (void) argv1;
-  Napi::Value argv2 = info[2]; (void) argv2;
-}
-
-static void FourArgFunction(const Napi::CallbackInfo& info) {
-  Napi::Value argv0 = info[0]; (void) argv0;
-  Napi::Value argv1 = info[1]; (void) argv1;
-  Napi::Value argv2 = info[2]; (void) argv2;
-  Napi::Value argv3 = info[3]; (void) argv3;
-}
-
-#if NAPI_VERSION > 5
-class FunctionArgsBenchmark : public Napi::Addon<FunctionArgsBenchmark> {
- public:
-  FunctionArgsBenchmark(Napi::Env env, Napi::Object exports) {
-    DefineAddon(exports, {
-      InstanceValue("addon", DefineProperties(Napi::Object::New(env), {
-        InstanceMethod("noArgFunction", &FunctionArgsBenchmark::NoArgFunction),
-        InstanceMethod("oneArgFunction",
-                       &FunctionArgsBenchmark::OneArgFunction),
-        InstanceMethod("twoArgFunction",
-                       &FunctionArgsBenchmark::TwoArgFunction),
-        InstanceMethod("threeArgFunction",
-                       &FunctionArgsBenchmark::ThreeArgFunction),
-        InstanceMethod("fourArgFunction",
-                       &FunctionArgsBenchmark::FourArgFunction),
-      }), napi_enumerable),
-      InstanceValue("addon_templated",
-        DefineProperties(Napi::Object::New(env), {
-          InstanceMethod<&FunctionArgsBenchmark::NoArgFunction>(
-                                                            "noArgFunction"),
-          InstanceMethod<&FunctionArgsBenchmark::OneArgFunction>(
-                                                            "oneArgFunction"),
-          InstanceMethod<&FunctionArgsBenchmark::TwoArgFunction>(
-                                                            "twoArgFunction"),
-          InstanceMethod<&FunctionArgsBenchmark::ThreeArgFunction>(
-                                                            "threeArgFunction"),
-          InstanceMethod<&FunctionArgsBenchmark::FourArgFunction>(
-                                                            "fourArgFunction"),
-        }), napi_enumerable),
-    });
-  }
- private:
-  void NoArgFunction(const Napi::CallbackInfo& info) {
-    (void) info;
-  }
-
-  void OneArgFunction(const Napi::CallbackInfo& info) {
-    Napi::Value argv0 = info[0]; (void) argv0;
-  }
-
-  void TwoArgFunction(const Napi::CallbackInfo& info) {
-    Napi::Value argv0 = info[0]; (void) argv0;
-    Napi::Value argv1 = info[1]; (void) argv1;
-  }
-
-  void ThreeArgFunction(const Napi::CallbackInfo& info) {
-    Napi::Value argv0 = info[0]; (void) argv0;
-    Napi::Value argv1 = info[1]; (void) argv1;
-    Napi::Value argv2 = info[2]; (void) argv2;
-  }
-
-  void FourArgFunction(const Napi::CallbackInfo& info) {
-    Napi::Value argv0 = info[0]; (void) argv0;
-    Napi::Value argv1 = info[1]; (void) argv1;
-    Napi::Value argv2 = info[2]; (void) argv2;
-    Napi::Value argv3 = info[3]; (void) argv3;
-  }
-};
-#endif  // NAPI_VERSION > 5
-
-static Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  napi_value no_arg_function, one_arg_function, two_arg_function,
-      three_arg_function, four_arg_function;
-  napi_status status;
-
-  status = napi_create_function(env,
-                                "noArgFunction",
-                                NAPI_AUTO_LENGTH,
-                                NoArgFunction_Core,
-                                nullptr,
-                                &no_arg_function);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  status = napi_create_function(env,
-                                "oneArgFunction",
-                                NAPI_AUTO_LENGTH,
-                                OneArgFunction_Core,
-                                nullptr,
-                                &one_arg_function);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  status = napi_create_function(env,
-                                "twoArgFunction",
-                                NAPI_AUTO_LENGTH,
-                                TwoArgFunction_Core,
-                                nullptr,
-                                &two_arg_function);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  status = napi_create_function(env,
-                                "threeArgFunction",
-                                NAPI_AUTO_LENGTH,
-                                ThreeArgFunction_Core,
-                                nullptr,
-                                &three_arg_function);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  status = napi_create_function(env,
-                                "fourArgFunction",
-                                NAPI_AUTO_LENGTH,
-                                FourArgFunction_Core,
-                                nullptr,
-                                &four_arg_function);
-  NAPI_THROW_IF_FAILED(env, status, Napi::Object());
-
-  Napi::Object core = Napi::Object::New(env);
-  core["noArgFunction"] = Napi::Value(env, no_arg_function);
-  core["oneArgFunction"] = Napi::Value(env, one_arg_function);
-  core["twoArgFunction"] = Napi::Value(env, two_arg_function);
-  core["threeArgFunction"] = Napi::Value(env, three_arg_function);
-  core["fourArgFunction"] = Napi::Value(env, four_arg_function);
-  exports["core"] = core;
-
-  Napi::Object cplusplus = Napi::Object::New(env);
-  cplusplus["noArgFunction"] = Napi::Function::New(env, NoArgFunction);
-  cplusplus["oneArgFunction"] = Napi::Function::New(env, OneArgFunction);
-  cplusplus["twoArgFunction"] = Napi::Function::New(env, TwoArgFunction);
-  cplusplus["threeArgFunction"] = Napi::Function::New(env, ThreeArgFunction);
-  cplusplus["fourArgFunction"] = Napi::Function::New(env, FourArgFunction);
-  exports["cplusplus"] = cplusplus;
-
-  Napi::Object templated = Napi::Object::New(env);
-  templated["noArgFunction"] = Napi::Function::New<NoArgFunction>(env);
-  templated["oneArgFunction"] = Napi::Function::New<OneArgFunction>(env);
-  templated["twoArgFunction"] = Napi::Function::New<TwoArgFunction>(env);
-  templated["threeArgFunction"] = Napi::Function::New<ThreeArgFunction>(env);
-  templated["fourArgFunction"] = Napi::Function::New<FourArgFunction>(env);
-  exports["templated"] = templated;
-
-#if NAPI_VERSION > 5
-  FunctionArgsBenchmark::Init(env, exports);
-#endif  // NAPI_VERSION > 5
-
-  return exports;
-}
-
-NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)