koffi 0.9.33 → 0.9.34

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

@@ -1,69 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('./testUtil');
-const safeBuffer = require('safe-buffer');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  return testUtil.runGCTests([
-    'Internal Buffer',
-    () => {
-      const test = binding.buffer.createBuffer();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-
-      const test2 = safeBuffer.Buffer.alloc(test.length);
-      test.copy(test2);
-      binding.buffer.checkBuffer(test2);
-    },
-
-    'Buffer copy',
-    () => {
-      const test = binding.buffer.createBufferCopy();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-    },
-
-    'External Buffer',
-    () => {
-      const test = binding.buffer.createExternalBuffer();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-      assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-
-    'External Buffer with finalizer',
-    () => {
-      const test = binding.buffer.createExternalBufferWithFinalize();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-      assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-    },
-    () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
-    },
-
-    'External Buffer with finalizer hint',
-    () => {
-        const test = binding.buffer.createExternalBufferWithFinalizeHint();
-        binding.buffer.checkBuffer(test);
-        assert.ok(test instanceof Buffer);
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-    },
-    () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
-    },
-  ]);
-}

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

@@ -1,22 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-#if (NAPI_VERSION > 2)
-namespace {
-
-static void RunInCallbackScope(const CallbackInfo& info) {
-  Function callback = info[0].As<Function>();
-  AsyncContext context(info.Env(), "callback_scope_test");
-  CallbackScope scope(info.Env(), context);
-  callback.Call({});
-}
-
-} // end anonymous namespace
-
-Object InitCallbackScope(Env env) {
-  Object exports = Object::New(env);
-  exports["runInCallbackScope"] = Function::New(env, RunInCallbackScope);
-  return exports;
-}
-#endif

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

@@ -1,49 +0,0 @@
-'use strict';
-const assert = require('assert');
-
-// we only check async hooks on 8.x an higher were
-// they are closer to working properly
-const nodeVersion = process.versions.node.split('.')[0]
-let async_hooks = undefined;
-function checkAsyncHooks() {
-  if (nodeVersion >= 8) {
-    if (async_hooks == undefined) {
-      async_hooks = require('async_hooks');
-    }
-    return true;
-  }
-  return false;
-}
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  if (!checkAsyncHooks())
-    return;
-
-  let id;
-  let insideHook = false;
-  const hook = async_hooks.createHook({
-    init(asyncId, type, triggerAsyncId, resource) {
-      if (id === undefined && type === 'callback_scope_test') {
-        id = asyncId;
-      }
-    },
-    before(asyncId) {
-      if (asyncId === id)
-        insideHook = true;
-    },
-    after(asyncId) {
-      if (asyncId === id)
-        insideHook = false;
-    }
-  }).enable();
-
-  return new Promise(resolve => {
-    binding.callbackscope.runInCallbackScope(function() {
-      assert(insideHook);
-      hook.disable();
-      resolve();
-    });
-  });
-}

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

@@ -1,114 +0,0 @@
-/* Test helpers ported from test/common/index.js in Node.js project. */
-'use strict';
-const assert = require('assert');
-const path = require('path');
-
-const noop = () => {};
-
-const mustCallChecks = [];
-
-function runCallChecks (exitCode) {
-  if (exitCode !== 0) return;
-
-  const failed = mustCallChecks.filter(function (context) {
-    if ('minimum' in context) {
-      context.messageSegment = `at least ${context.minimum}`;
-      return context.actual < context.minimum;
-    } else {
-      context.messageSegment = `exactly ${context.exact}`;
-      return context.actual !== context.exact;
-    }
-  });
-
-  failed.forEach(function (context) {
-    console.log('Mismatched %s function calls. Expected %s, actual %d.',
-      context.name,
-      context.messageSegment,
-      context.actual);
-    console.log(context.stack.split('\n').slice(2).join('\n'));
-  });
-
-  if (failed.length) process.exit(1);
-}
-
-exports.mustCall = function (fn, exact) {
-  return _mustCallInner(fn, exact, 'exact');
-};
-exports.mustCallAtLeast = function (fn, minimum) {
-  return _mustCallInner(fn, minimum, 'minimum');
-};
-
-function _mustCallInner (fn, criteria, field) {
-  if (typeof fn === 'number') {
-    criteria = fn;
-    fn = noop;
-  } else if (fn === undefined) {
-    fn = noop;
-  }
-  if (criteria === undefined) {
-    criteria = 1;
-  }
-
-  if (typeof criteria !== 'number') { throw new TypeError(`Invalid ${field} value: ${criteria}`); }
-
-  const context = {
-    [field]: criteria,
-    actual: 0,
-    stack: (new Error()).stack,
-    name: fn.name || '<anonymous>'
-  };
-
-  // add the exit listener only once to avoid listener leak warnings
-  if (mustCallChecks.length === 0) process.on('exit', runCallChecks);
-
-  mustCallChecks.push(context);
-
-  return function () {
-    context.actual++;
-    return fn.apply(this, arguments);
-  };
-}
-
-exports.mustNotCall = function (msg) {
-  return function mustNotCall () {
-    assert.fail(msg || 'function should not have been called');
-  };
-};
-
-exports.runTest = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-  const bindings = [
-    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_custom_namespace.node`)
-  ].map(it => require.resolve(it));
-
-  for (const item of bindings) {
-    await Promise.resolve(test(require(item)))
-      .finally(exports.mustCall());
-  }
-};
-
-exports.runTestWithBindingPath = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-  const bindings = [
-    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_custom_namespace.node`)
-  ].map(it => require.resolve(it));
-
-  for (const item of bindings) {
-    await test(item);
-  }
-};
-
-exports.runTestWithBuildType = async function (test, buildType) {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-  await Promise.resolve(test(buildType))
-    .finally(exports.mustCall());
-};

package/vendor/node-addon-api/test/common/test_helper.h

@@ -1,71 +0,0 @@
-#pragma once
-#include "napi.h"
-
-namespace Napi {
-
-// Needs this here since the MaybeUnwrap() functions need to be in the
-// same namespace as their arguments for C++ argument-dependent lookup
-#ifdef NAPI_CPP_CUSTOM_NAMESPACE
-namespace NAPI_CPP_CUSTOM_NAMESPACE {
-#endif
-
-// Use this when a variable or parameter is unused in order to explicitly
-// silence a compiler warning about that.
-template <typename T>
-inline void USE(T&&) {}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by checking that
- * MaybeOrValue is NOT an empty Maybe when NODE_ADDON_API_ENABLE_MAYBE is
- * defined.
- *
- * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline T MaybeUnwrap(MaybeOrValue<T> maybe) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.Unwrap();
-#else
-  return maybe;
-#endif
-}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by getting the value that
- * wrapped by the Maybe or return the default_value if the Maybe is empty when
- * NODE_ADDON_API_ENABLE_MAYBE is defined.
- *
- * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline T MaybeUnwrapOr(MaybeOrValue<T> maybe, const T& default_value) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.UnwrapOr(default_value);
-#else
-  USE(default_value);
-  return maybe;
-#endif
-}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by getting the value that
- * wrapped by the Maybe or return false if the Maybe is empty when
- * NODE_ADDON_API_ENABLE_MAYBE is defined.
- *
- * Copying the value to out when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.UnwrapTo(out);
-#else
-  *out = maybe;
-  return true;
-#endif
-}
-
-#ifdef NAPI_CPP_CUSTOM_NAMESPACE
-}  // namespace NAPI_CPP_CUSTOM_NAMESPACE
-#endif
-
-}  // namespace Napi

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

@@ -1,48 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static Value CreateDataView1(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  return DataView::New(info.Env(), arrayBuffer);
-}
-
-static Value CreateDataView2(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return DataView::New(info.Env(), arrayBuffer, byteOffset);
-}
-
-static Value CreateDataView3(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  size_t byteLength = info[2].As<Number>().Uint32Value();
-  return DataView::New(info.Env(), arrayBuffer, byteOffset, byteLength);
-}
-
-static Value GetArrayBuffer(const CallbackInfo& info) {
-  return info[0].As<DataView>().ArrayBuffer();
-}
-
-static Value GetByteOffset(const CallbackInfo& info) {
-  return Number::New(info.Env(),
-                     static_cast<double>(info[0].As<DataView>().ByteOffset()));
-}
-
-static Value GetByteLength(const CallbackInfo& info) {
-  return Number::New(info.Env(),
-                     static_cast<double>(info[0].As<DataView>().ByteLength()));
-}
-
-Object InitDataView(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createDataView1"] = Function::New(env, CreateDataView1);
-  exports["createDataView2"] = Function::New(env, CreateDataView2);
-  exports["createDataView3"] = Function::New(env, CreateDataView3);
-  exports["getArrayBuffer"] = Function::New(env, GetArrayBuffer);
-  exports["getByteOffset"] = Function::New(env, GetByteOffset);
-  exports["getByteLength"] = Function::New(env, GetByteLength);
-
-  return exports;
-}

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

@@ -1,35 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function testDataViewCreation(factory, arrayBuffer, offset, length) {
-    const view = factory(arrayBuffer, offset, length);
-    offset = offset ? offset : 0;
-    assert.ok(dataview.getArrayBuffer(view) instanceof ArrayBuffer);
-    assert.strictEqual(dataview.getArrayBuffer(view), arrayBuffer);
-    assert.strictEqual(dataview.getByteOffset(view), offset);
-    assert.strictEqual(dataview.getByteLength(view),
-        length ? length : arrayBuffer.byteLength - offset);
-  }
-
-  function testInvalidRange(factory, arrayBuffer, offset, length) {
-    assert.throws(() => {
-      factory(arrayBuffer, offset, length);
-    }, RangeError);
-  }
-
-  const dataview = binding.dataview;
-  const arrayBuffer = new ArrayBuffer(10);
-
-  testDataViewCreation(dataview.createDataView1, arrayBuffer);
-  testDataViewCreation(dataview.createDataView2, arrayBuffer, 2);
-  testDataViewCreation(dataview.createDataView2, arrayBuffer, 10);
-  testDataViewCreation(dataview.createDataView3, arrayBuffer, 2, 4);
-  testDataViewCreation(dataview.createDataView3, arrayBuffer, 10, 0);
-
-  testInvalidRange(dataview.createDataView2, arrayBuffer, 11);
-  testInvalidRange(dataview.createDataView3, arrayBuffer, 11, 0);
-  testInvalidRange(dataview.createDataView3, arrayBuffer, 6, 5);
-}

package/vendor/node-addon-api/test/dataview/dataview_read_write.cc

@@ -1,115 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static Value GetFloat32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetFloat32(byteOffset));
-}
-
-static Value GetFloat64(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetFloat64(byteOffset));
-}
-
-static Value GetInt8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt8(byteOffset));
-}
-
-static Value GetInt16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt16(byteOffset));
-}
-
-static Value GetInt32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt32(byteOffset));
-}
-
-static Value GetUint8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint8(byteOffset));
-}
-
-static Value GetUint16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint16(byteOffset));
-}
-
-static Value GetUint32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint32(byteOffset));
-}
-
-static void SetFloat32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().FloatValue();
-  info[0].As<DataView>().SetFloat32(byteOffset, value);
-}
-
-static void SetFloat64(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().DoubleValue();
-  info[0].As<DataView>().SetFloat64(byteOffset, value);
-}
-
-static void SetInt8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt8(byteOffset, value);
-}
-
-static void SetInt16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt16(byteOffset, value);
-}
-
-static void SetInt32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt32(byteOffset, value);
-}
-
-static void SetUint8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint8(byteOffset, value);
-}
-
-static void SetUint16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint16(byteOffset, value);
-}
-
-static void SetUint32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint32(byteOffset, value);
-}
-
-Object InitDataViewReadWrite(Env env) {
-  Object exports = Object::New(env);
-
-  exports["getFloat32"] = Function::New(env, GetFloat32);
-  exports["getFloat64"] = Function::New(env, GetFloat64);
-  exports["getInt8"] = Function::New(env, GetInt8);
-  exports["getInt16"] = Function::New(env, GetInt16);
-  exports["getInt32"] = Function::New(env, GetInt32);
-  exports["getUint8"] = Function::New(env, GetUint8);
-  exports["getUint16"] = Function::New(env, GetUint16);
-  exports["getUint32"] = Function::New(env, GetUint32);
-
-  exports["setFloat32"] = Function::New(env, SetFloat32);
-  exports["setFloat64"] = Function::New(env, SetFloat64);
-  exports["setInt8"] = Function::New(env, SetInt8);
-  exports["setInt16"] = Function::New(env, SetInt16);
-  exports["setInt32"] = Function::New(env, SetInt32);
-  exports["setUint8"] = Function::New(env, SetUint8);
-  exports["setUint16"] = Function::New(env, SetUint16);
-  exports["setUint32"] = Function::New(env, SetUint32);
-
-  return exports;
-}

package/vendor/node-addon-api/test/dataview/dataview_read_write.js

@@ -1,90 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function expected(type, value) {
-    return eval(`(new ${type}Array([${value}]))[0]`);
-  }
-
-  function nativeReadDataView(dataview, type, offset, value) {
-    return eval(`binding.dataview_read_write.get${type}(dataview, offset)`);
-  }
-
-  function nativeWriteDataView(dataview, type, offset, value) {
-    eval(`binding.dataview_read_write.set${type}(dataview, offset, value)`);
-  }
-
-  function isLittleEndian() {
-    const buffer = new ArrayBuffer(2);
-    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
-    return new Int16Array(buffer)[0] === 256;
-  }
-
-  function jsReadDataView(dataview, type, offset, value) {
-    return eval(`dataview.get${type}(offset, isLittleEndian())`);
-  }
-
-  function jsWriteDataView(dataview, type, offset, value) {
-    eval(`dataview.set${type}(offset, value, isLittleEndian())`);
-  }
-
-  function testReadData(dataview, type, offset, value) {
-    jsWriteDataView(dataview, type, offset, 0);
-    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
-
-    jsWriteDataView(dataview, type, offset, value);
-    assert.strictEqual(
-        nativeReadDataView(dataview, type, offset), expected(type, value));
-  }
-
-  function testWriteData(dataview, type, offset, value) {
-    jsWriteDataView(dataview, type, offset, 0);
-    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
-
-    nativeWriteDataView(dataview, type, offset, value);
-    assert.strictEqual(
-        jsReadDataView(dataview, type, offset), expected(type, value));
-  }
-
-  function testInvalidOffset(dataview, type, offset, value) {
-    assert.throws(() => {
-      nativeReadDataView(dataview, type, offset);
-    }, RangeError);
-
-    assert.throws(() => {
-      nativeWriteDataView(dataview, type, offset, value);
-    }, RangeError);
-  }
-
-  const dataview = new DataView(new ArrayBuffer(22));
-
-  testReadData(dataview, 'Float32', 0, 10.2);
-  testReadData(dataview, 'Float64', 4, 20.3);
-  testReadData(dataview, 'Int8', 5, 120);
-  testReadData(dataview, 'Int16', 7, 15000);
-  testReadData(dataview, 'Int32', 11, 200000);
-  testReadData(dataview, 'Uint8', 12, 128);
-  testReadData(dataview, 'Uint16', 14, 32768);
-  testReadData(dataview, 'Uint32', 18, 1000000);
-
-  testWriteData(dataview, 'Float32', 0, 10.2);
-  testWriteData(dataview, 'Float64', 4, 20.3);
-  testWriteData(dataview, 'Int8', 5, 120);
-  testWriteData(dataview, 'Int16', 7, 15000);
-  testWriteData(dataview, 'Int32', 11, 200000);
-  testWriteData(dataview, 'Uint8', 12, 128);
-  testWriteData(dataview, 'Uint16', 14, 32768);
-  testWriteData(dataview, 'Uint32', 18, 1000000);
-
-  testInvalidOffset(dataview, 'Float32', 22, 10.2);
-  testInvalidOffset(dataview, 'Float64', 22, 20.3);
-  testInvalidOffset(dataview, 'Int8', 22, 120);
-  testInvalidOffset(dataview, 'Int16', 22, 15000);
-  testInvalidOffset(dataview, 'Int32', 22, 200000);
-  testInvalidOffset(dataview, 'Uint8', 22, 128);
-  testInvalidOffset(dataview, 'Uint16', 22, 32768);
-  testInvalidOffset(dataview, 'Uint32', 22, 1000000);
-}

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

@@ -1,44 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-#if (NAPI_VERSION > 4)
-namespace {
-
-Value CreateDate(const CallbackInfo& info) {
-  double input = info[0].As<Number>().DoubleValue();
-
-  return Date::New(info.Env(), input);
-}
-
-Value IsDate(const CallbackInfo& info) {
-  Date input = info[0].As<Date>();
-
-  return Boolean::New(info.Env(), input.IsDate());
-}
-
-Value ValueOf(const CallbackInfo& info) {
-  Date input = info[0].As<Date>();
-
-  return Number::New(info.Env(), input.ValueOf());
-}
-
-Value OperatorValue(const CallbackInfo& info) {
-  Date input = info[0].As<Date>();
-
-  return Boolean::New(info.Env(), input.ValueOf() == static_cast<double>(input));
-}
-
-}  // anonymous namespace
-
-Object InitDate(Env env) {
-  Object exports = Object::New(env);
-  exports["CreateDate"] = Function::New(env, CreateDate);
-  exports["IsDate"] = Function::New(env, IsDate);
-  exports["ValueOf"] = Function::New(env, ValueOf);
-  exports["OperatorValue"] = Function::New(env, OperatorValue);
-
-  return exports;
-}
-
-#endif

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

@@ -1,18 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  const {
-    CreateDate,
-    IsDate,
-    ValueOf,
-    OperatorValue,
-  } = binding.date;
-  assert.deepStrictEqual(CreateDate(0), new Date(0));
-  assert.strictEqual(IsDate(new Date(0)), true);
-  assert.strictEqual(ValueOf(new Date(42)), 42);
-  assert.strictEqual(OperatorValue(new Date(42)), true);
-}