koffi 0.9.2 → 0.9.5

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

@@ -1,121 +1,121 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(binding => {
-  test(binding.function.plain);
-  test(binding.function.templated);
-  testLambda(binding.function.lambda);
-});
-
-function test(binding) {
-  assert.strictEqual(binding.emptyConstructor(true), true);
-  assert.strictEqual(binding.emptyConstructor(false), false);
-
-  let obj = {};
-  assert.deepStrictEqual(binding.voidCallback(obj), undefined);
-  assert.deepStrictEqual(obj, { "foo": "bar" });
-
-  assert.deepStrictEqual(binding.valueCallback(), { "foo": "bar" });
-
-  let args = null;
-  let ret = null;
-  let receiver = null;
-  function testFunction() {
-    receiver = this;
-    args = [].slice.call(arguments);
-    return ret;
-  }
-  function testConstructor() {
-    args = [].slice.call(arguments);
-  }
-
-  function makeCallbackTestFunction(receiver, expectedOne, expectedTwo, expectedThree) {
-    return function callback(one, two, three) {
-      assert.strictEqual(this, receiver);
-      assert.strictEqual(one, expectedOne);
-      assert.strictEqual(two, expectedTwo);
-      assert.strictEqual(three, expectedThree);
-    }
-  }
-
-  ret = 4;
-  assert.strictEqual(binding.callWithArgs(testFunction, 1, 2, 3), 4);
-  assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 1, 2, 3 ]);
-
-  ret = 5;
-  assert.strictEqual(binding.callWithVector(testFunction, 2, 3, 4), 5);
-  assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 2, 3, 4 ]);
-
-  ret = 6;
-  assert.strictEqual(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
-  assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 3, 4, 5 ]);
-
-  ret = 7;
-  assert.strictEqual(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
-  assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 4, 5, 6 ]);
-
-  ret = 8;
-  assert.strictEqual(binding.callWithCStyleArray(testFunction, 5, 6, 7), ret);
-  assert.deepStrictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
-
-  ret = 9;
-  assert.strictEqual(binding.callWithReceiverAndCStyleArray(testFunction, obj, 6, 7, 8), ret);
-  assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
-
-  ret = 10;
-  assert.strictEqual(binding.callWithFunctionOperator(testFunction, 7, 8, 9), ret);
-  assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
-
-  assert.throws(() => {
-    binding.callWithInvalidReceiver();
-  }, /Invalid (pointer passed as )?argument/);
-
-  obj = binding.callConstructorWithArgs(testConstructor, 5, 6, 7);
-  assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
-
-  obj = binding.callConstructorWithVector(testConstructor, 6, 7, 8);
-  assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
-
-  obj = binding.callConstructorWithCStyleArray(testConstructor, 7, 8, 9);
-  assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
-
-  obj = {};
-  assert.deepStrictEqual(binding.voidCallbackWithData(obj), undefined);
-  assert.deepStrictEqual(obj, { "foo": "bar", "data": 1 });
-
-  assert.deepStrictEqual(binding.valueCallbackWithData(), { "foo": "bar", "data": 1 });
-
-  assert.strictEqual(binding.voidCallback.name, 'voidCallback');
-  assert.strictEqual(binding.valueCallback.name, 'valueCallback');
-
-  let testConstructCall = undefined;
-  binding.isConstructCall((result) => { testConstructCall = result; });
-  assert.ok(!testConstructCall);
-  new binding.isConstructCall((result) => { testConstructCall = result; });
-  assert.ok(testConstructCall);
-
-  obj = {};
-  binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, "1", "2", "3"), obj, "1", "2", "3");
-  binding.makeCallbackWithVector(makeCallbackTestFunction(obj, 4, 5, 6), obj, 4, 5, 6);
-  binding.makeCallbackWithCStyleArray(makeCallbackTestFunction(obj, 7, 8, 9), obj, 7, 8, 9);
-  assert.throws(() => {
-    binding.makeCallbackWithInvalidReceiver(() => {});
-  });
-}
-
-function testLambda(binding) {
-  assert.ok(binding.lambdaWithNoCapture());
-  assert.ok(binding.lambdaWithCapture());
-  assert.ok(binding.lambdaWithMoveOnlyCapture());
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(binding => {
+  test(binding.function.plain);
+  test(binding.function.templated);
+  testLambda(binding.function.lambda);
+});
+
+function test(binding) {
+  assert.strictEqual(binding.emptyConstructor(true), true);
+  assert.strictEqual(binding.emptyConstructor(false), false);
+
+  let obj = {};
+  assert.deepStrictEqual(binding.voidCallback(obj), undefined);
+  assert.deepStrictEqual(obj, { "foo": "bar" });
+
+  assert.deepStrictEqual(binding.valueCallback(), { "foo": "bar" });
+
+  let args = null;
+  let ret = null;
+  let receiver = null;
+  function testFunction() {
+    receiver = this;
+    args = [].slice.call(arguments);
+    return ret;
+  }
+  function testConstructor() {
+    args = [].slice.call(arguments);
+  }
+
+  function makeCallbackTestFunction(receiver, expectedOne, expectedTwo, expectedThree) {
+    return function callback(one, two, three) {
+      assert.strictEqual(this, receiver);
+      assert.strictEqual(one, expectedOne);
+      assert.strictEqual(two, expectedTwo);
+      assert.strictEqual(three, expectedThree);
+    }
+  }
+
+  ret = 4;
+  assert.strictEqual(binding.callWithArgs(testFunction, 1, 2, 3), 4);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [ 1, 2, 3 ]);
+
+  ret = 5;
+  assert.strictEqual(binding.callWithVector(testFunction, 2, 3, 4), 5);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [ 2, 3, 4 ]);
+
+  ret = 6;
+  assert.strictEqual(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [ 3, 4, 5 ]);
+
+  ret = 7;
+  assert.strictEqual(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [ 4, 5, 6 ]);
+
+  ret = 8;
+  assert.strictEqual(binding.callWithCStyleArray(testFunction, 5, 6, 7), ret);
+  assert.deepStrictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
+
+  ret = 9;
+  assert.strictEqual(binding.callWithReceiverAndCStyleArray(testFunction, obj, 6, 7, 8), ret);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
+
+  ret = 10;
+  assert.strictEqual(binding.callWithFunctionOperator(testFunction, 7, 8, 9), ret);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
+
+  assert.throws(() => {
+    binding.callWithInvalidReceiver();
+  }, /Invalid (pointer passed as )?argument/);
+
+  obj = binding.callConstructorWithArgs(testConstructor, 5, 6, 7);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
+
+  obj = binding.callConstructorWithVector(testConstructor, 6, 7, 8);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
+
+  obj = binding.callConstructorWithCStyleArray(testConstructor, 7, 8, 9);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
+
+  obj = {};
+  assert.deepStrictEqual(binding.voidCallbackWithData(obj), undefined);
+  assert.deepStrictEqual(obj, { "foo": "bar", "data": 1 });
+
+  assert.deepStrictEqual(binding.valueCallbackWithData(), { "foo": "bar", "data": 1 });
+
+  assert.strictEqual(binding.voidCallback.name, 'voidCallback');
+  assert.strictEqual(binding.valueCallback.name, 'valueCallback');
+
+  let testConstructCall = undefined;
+  binding.isConstructCall((result) => { testConstructCall = result; });
+  assert.ok(!testConstructCall);
+  new binding.isConstructCall((result) => { testConstructCall = result; });
+  assert.ok(testConstructCall);
+
+  obj = {};
+  binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, "1", "2", "3"), obj, "1", "2", "3");
+  binding.makeCallbackWithVector(makeCallbackTestFunction(obj, 4, 5, 6), obj, 4, 5, 6);
+  binding.makeCallbackWithCStyleArray(makeCallbackTestFunction(obj, 7, 8, 9), obj, 7, 8, 9);
+  assert.throws(() => {
+    binding.makeCallbackWithInvalidReceiver(() => {});
+  });
+}
+
+function testLambda(binding) {
+  assert.ok(binding.lambdaWithNoCapture());
+  assert.ok(binding.lambdaWithCapture());
+  assert.ok(binding.lambdaWithMoveOnlyCapture());
+}

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

@@ -1,202 +1,202 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-class FuncRefObject : public Napi::ObjectWrap<FuncRefObject> {
- public:
-  FuncRefObject(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<FuncRefObject>(info) {
-    Napi::Env env = info.Env();
-    int argLen = info.Length();
-    if (argLen <= 0 || !info[0].IsNumber()) {
-      Napi::TypeError::New(env, "First param should be a number")
-          .ThrowAsJavaScriptException();
-      return;
-    }
-    Napi::Number value = info[0].As<Napi::Number>();
-    this->_value = value.Int32Value();
-  }
-
-  Napi::Value GetValue(const Napi::CallbackInfo& info) {
-    int value = this->_value;
-    return Napi::Number::New(info.Env(), value);
-  }
-
- private:
-  int _value;
-};
-
-namespace {
-
-Value ConstructRefFromExisitingRef(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  FunctionReference movedRef;
-  ref.Reset(info[0].As<Function>());
-  movedRef = std::move(ref);
-
-  return MaybeUnwrap(movedRef({}));
-}
-
-Value CallWithVectorArgs(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  std::vector<napi_value> newVec;
-  FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  for (int i = 1; i < (int)info.Length(); i++) {
-    newVec.push_back(info[i]);
-  }
-  return MaybeUnwrap(ref.Call(newVec));
-}
-
-Value CallWithInitList(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  return MaybeUnwrap(ref.Call({info[1], info[2], info[3]}));
-}
-
-Value CallWithRecvInitList(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  return MaybeUnwrap(ref.Call(info[1], {info[2], info[3], info[4]}));
-}
-
-Value CallWithRecvVector(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  std::vector<napi_value> newVec;
-  ref.Reset(info[0].As<Function>());
-
-  for (int i = 2; i < (int)info.Length(); i++) {
-    newVec.push_back(info[i]);
-  }
-  return MaybeUnwrap(ref.Call(info[1], newVec));
-}
-
-Value CallWithRecvArgc(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  int argLength = info.Length() - 2;
-  napi_value* args = new napi_value[argLength];
-  ref.Reset(info[0].As<Function>());
-
-  int argIdx = 0;
-  for (int i = 2; i < (int)info.Length(); i++, argIdx++) {
-    args[argIdx] = info[i];
-  }
-
-  return MaybeUnwrap(ref.Call(info[1], argLength, args));
-}
-
-Value MakeAsyncCallbackWithInitList(const Napi::CallbackInfo& info) {
-  Napi::FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
-
-  return MaybeUnwrap(
-      ref.MakeCallback(Napi::Object::New(info.Env()), {}, context));
-}
-
-Value MakeAsyncCallbackWithVector(const Napi::CallbackInfo& info) {
-  Napi::FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-  std::vector<napi_value> newVec;
-  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
-
-  for (int i = 1; i < (int)info.Length(); i++) {
-    newVec.push_back(info[i]);
-  }
-
-  return MaybeUnwrap(
-      ref.MakeCallback(Napi::Object::New(info.Env()), newVec, context));
-}
-
-Value MakeAsyncCallbackWithArgv(const Napi::CallbackInfo& info) {
-  Napi::FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-  int argLength = info.Length() - 1;
-  napi_value* args = new napi_value[argLength];
-
-  int argIdx = 0;
-  for (int i = 1; i < (int)info.Length(); i++, argIdx++) {
-    args[argIdx] = info[i];
-  }
-
-  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
-  return MaybeUnwrap(ref.MakeCallback(
-      Napi::Object::New(info.Env()), argLength, args, context));
-}
-
-Value CreateFunctionReferenceUsingNew(const Napi::CallbackInfo& info) {
-  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
-      info.Env(),
-      "MyObject",
-      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
-                                                 &FuncRefObject::GetValue)});
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-
-  return MaybeUnwrapOr(constructor->New({info[0].As<Number>()}), Object());
-}
-
-Value CreateFunctionReferenceUsingNewVec(const Napi::CallbackInfo& info) {
-  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
-      info.Env(),
-      "MyObject",
-      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
-                                                 &FuncRefObject::GetValue)});
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-  std::vector<napi_value> newVec;
-  newVec.push_back(info[0]);
-
-  return MaybeUnwrapOr(constructor->New(newVec), Object());
-}
-
-Value Call(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  return MaybeUnwrapOr(ref.Call({}), Value());
-}
-
-Value Construct(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  FunctionReference ref;
-  ref.Reset(info[0].As<Function>());
-
-  return MaybeUnwrapOr(ref.New({}), Object());
-}
-}  // namespace
-
-Object InitFunctionReference(Env env) {
-  Object exports = Object::New(env);
-  exports["CreateFuncRefWithNew"] =
-      Function::New(env, CreateFunctionReferenceUsingNew);
-  exports["CreateFuncRefWithNewVec"] =
-      Function::New(env, CreateFunctionReferenceUsingNewVec);
-  exports["CallWithRecvArgc"] = Function::New(env, CallWithRecvArgc);
-  exports["CallWithRecvVector"] = Function::New(env, CallWithRecvVector);
-  exports["CallWithRecvInitList"] = Function::New(env, CallWithRecvInitList);
-  exports["CallWithInitList"] = Function::New(env, CallWithInitList);
-  exports["CallWithVec"] = Function::New(env, CallWithVectorArgs);
-  exports["ConstructWithMove"] =
-      Function::New(env, ConstructRefFromExisitingRef);
-  exports["AsyncCallWithInitList"] =
-      Function::New(env, MakeAsyncCallbackWithInitList);
-  exports["AsyncCallWithVector"] =
-      Function::New(env, MakeAsyncCallbackWithVector);
-  exports["AsyncCallWithArgv"] = Function::New(env, MakeAsyncCallbackWithArgv);
-  exports["call"] = Function::New(env, Call);
-  exports["construct"] = Function::New(env, Construct);
-
-  return exports;
-}
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+class FuncRefObject : public Napi::ObjectWrap<FuncRefObject> {
+ public:
+  FuncRefObject(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<FuncRefObject>(info) {
+    Napi::Env env = info.Env();
+    int argLen = info.Length();
+    if (argLen <= 0 || !info[0].IsNumber()) {
+      Napi::TypeError::New(env, "First param should be a number")
+          .ThrowAsJavaScriptException();
+      return;
+    }
+    Napi::Number value = info[0].As<Napi::Number>();
+    this->_value = value.Int32Value();
+  }
+
+  Napi::Value GetValue(const Napi::CallbackInfo& info) {
+    int value = this->_value;
+    return Napi::Number::New(info.Env(), value);
+  }
+
+ private:
+  int _value;
+};
+
+namespace {
+
+Value ConstructRefFromExisitingRef(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  FunctionReference movedRef;
+  ref.Reset(info[0].As<Function>());
+  movedRef = std::move(ref);
+
+  return MaybeUnwrap(movedRef({}));
+}
+
+Value CallWithVectorArgs(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  std::vector<napi_value> newVec;
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  for (int i = 1; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+  return MaybeUnwrap(ref.Call(newVec));
+}
+
+Value CallWithInitList(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrap(ref.Call({info[1], info[2], info[3]}));
+}
+
+Value CallWithRecvInitList(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrap(ref.Call(info[1], {info[2], info[3], info[4]}));
+}
+
+Value CallWithRecvVector(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  std::vector<napi_value> newVec;
+  ref.Reset(info[0].As<Function>());
+
+  for (int i = 2; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+  return MaybeUnwrap(ref.Call(info[1], newVec));
+}
+
+Value CallWithRecvArgc(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  int argLength = info.Length() - 2;
+  napi_value* args = new napi_value[argLength];
+  ref.Reset(info[0].As<Function>());
+
+  int argIdx = 0;
+  for (int i = 2; i < (int)info.Length(); i++, argIdx++) {
+    args[argIdx] = info[i];
+  }
+
+  return MaybeUnwrap(ref.Call(info[1], argLength, args));
+}
+
+Value MakeAsyncCallbackWithInitList(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+
+  return MaybeUnwrap(
+      ref.MakeCallback(Napi::Object::New(info.Env()), {}, context));
+}
+
+Value MakeAsyncCallbackWithVector(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+  std::vector<napi_value> newVec;
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+
+  for (int i = 1; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+
+  return MaybeUnwrap(
+      ref.MakeCallback(Napi::Object::New(info.Env()), newVec, context));
+}
+
+Value MakeAsyncCallbackWithArgv(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+  int argLength = info.Length() - 1;
+  napi_value* args = new napi_value[argLength];
+
+  int argIdx = 0;
+  for (int i = 1; i < (int)info.Length(); i++, argIdx++) {
+    args[argIdx] = info[i];
+  }
+
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+  return MaybeUnwrap(ref.MakeCallback(
+      Napi::Object::New(info.Env()), argLength, args, context));
+}
+
+Value CreateFunctionReferenceUsingNew(const Napi::CallbackInfo& info) {
+  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
+      info.Env(),
+      "MyObject",
+      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
+                                                 &FuncRefObject::GetValue)});
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+  *constructor = Napi::Persistent(func);
+
+  return MaybeUnwrapOr(constructor->New({info[0].As<Number>()}), Object());
+}
+
+Value CreateFunctionReferenceUsingNewVec(const Napi::CallbackInfo& info) {
+  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
+      info.Env(),
+      "MyObject",
+      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
+                                                 &FuncRefObject::GetValue)});
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+  *constructor = Napi::Persistent(func);
+  std::vector<napi_value> newVec;
+  newVec.push_back(info[0]);
+
+  return MaybeUnwrapOr(constructor->New(newVec), Object());
+}
+
+Value Call(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrapOr(ref.Call({}), Value());
+}
+
+Value Construct(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrapOr(ref.New({}), Object());
+}
+}  // namespace
+
+Object InitFunctionReference(Env env) {
+  Object exports = Object::New(env);
+  exports["CreateFuncRefWithNew"] =
+      Function::New(env, CreateFunctionReferenceUsingNew);
+  exports["CreateFuncRefWithNewVec"] =
+      Function::New(env, CreateFunctionReferenceUsingNewVec);
+  exports["CallWithRecvArgc"] = Function::New(env, CallWithRecvArgc);
+  exports["CallWithRecvVector"] = Function::New(env, CallWithRecvVector);
+  exports["CallWithRecvInitList"] = Function::New(env, CallWithRecvInitList);
+  exports["CallWithInitList"] = Function::New(env, CallWithInitList);
+  exports["CallWithVec"] = Function::New(env, CallWithVectorArgs);
+  exports["ConstructWithMove"] =
+      Function::New(env, ConstructRefFromExisitingRef);
+  exports["AsyncCallWithInitList"] =
+      Function::New(env, MakeAsyncCallbackWithInitList);
+  exports["AsyncCallWithVector"] =
+      Function::New(env, MakeAsyncCallbackWithVector);
+  exports["AsyncCallWithArgv"] = Function::New(env, MakeAsyncCallbackWithArgv);
+  exports["call"] = Function::New(env, Call);
+  exports["construct"] = Function::New(env, Construct);
+
+  return exports;
+}