koffi 2.16.0-beta.2 → 2.16.1

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

@@ -1,246 +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 { access } = require('node:fs/promises');
-const { spawn } = require('child_process');
-const { EOL } = require('os');
-const readline = require('readline');
-
-const escapeBackslashes = (pathString) => pathString.split('\\').join('\\\\');
-
-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(EOL).slice(2).join(EOL));
-  });
-
-  if (failed.length) process.exit(1);
-}
-
-exports.installAysncHooks = function (asyncResName) {
-  const asyncHooks = require('async_hooks');
-  return new Promise((resolve, reject) => {
-    let id;
-    const events = [];
-    /**
-     * TODO(legendecas): investigate why resolving & disabling hooks in
-     * destroy callback causing crash with case 'callbackscope.js'.
-     */
-    let destroyed = false;
-    const hook = asyncHooks.createHook({
-      init (asyncId, type, triggerAsyncId, resource) {
-        if (id === undefined && type === asyncResName) {
-          id = asyncId;
-          events.push({ eventName: 'init', type, triggerAsyncId, resource });
-        }
-      },
-      before (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'before' });
-        }
-      },
-      after (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'after' });
-        }
-      },
-      destroy (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'destroy' });
-          destroyed = true;
-        }
-      }
-    }).enable();
-
-    const interval = setInterval(() => {
-      if (destroyed) {
-        hook.disable();
-        clearInterval(interval);
-        resolve(events);
-      }
-    }, 10);
-  });
-};
-
-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');
-  };
-};
-
-const buildTypes = {
-  Release: 'Release',
-  Debug: 'Debug'
-};
-
-async function checkBuildType (buildType) {
-  try {
-    await access(path.join(path.resolve('./test/build'), buildType));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function whichBuildType () {
-  let buildType = 'Release';
-  const envBuildType = process.env.NODE_API_BUILD_CONFIG || (process.env.npm_config_debug === 'true' ? 'Debug' : 'Release');
-  if (envBuildType) {
-    if (Object.values(buildTypes).includes(envBuildType)) {
-      if (await checkBuildType(envBuildType)) {
-        buildType = envBuildType;
-      } else {
-        throw new Error(`The ${envBuildType} build doesn't exist.`);
-      }
-    } else {
-      throw new Error('Invalid value for NODE_API_BUILD_CONFIG environment variable. It should be set to Release or Debug.');
-    }
-  }
-  return buildType;
-}
-
-exports.whichBuildType = whichBuildType;
-
-exports.runTest = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || await whichBuildType();
-  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), { bindingPath: item }))
-      .finally(exports.mustCall());
-  }
-};
-
-exports.runTestWithBindingPath = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || await whichBuildType();
-
-  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 || await whichBuildType();
-
-  await Promise.resolve(test(buildType))
-    .finally(exports.mustCall());
-};
-
-// Some tests have to run in their own process, otherwise they would interfere
-// with each other. Such tests export a factory function rather than the test
-// itself so as to avoid automatic instantiation, and therefore interference,
-// in the main process. Two examples are addon and addon_data, both of which
-// use Napi::Env::SetInstanceData(). This helper function provides a common
-// approach for running such tests.
-exports.runTestInChildProcess = function ({ suite, testName, expectedStderr, execArgv }) {
-  return exports.runTestWithBindingPath((bindingName) => {
-    return new Promise((resolve) => {
-      bindingName = escapeBackslashes(bindingName);
-      // Test suites are assumed to be located here.
-      const suitePath = escapeBackslashes(path.join(__dirname, '..', 'child_processes', suite));
-      const child = spawn(process.execPath, [
-        '--expose-gc',
-        ...(execArgv ?? []),
-        '-e',
-        `require('${suitePath}').${testName}(require('${bindingName}'))`
-      ]);
-      const resultOfProcess = { stderr: [] };
-
-      // Capture the exit code and signal.
-      child.on('close', (code, signal) => resolve(Object.assign(resultOfProcess, { code, signal })));
-
-      // Capture the stderr as an array of lines.
-      readline
-        .createInterface({ input: child.stderr })
-        .on('line', (line) => {
-          resultOfProcess.stderr.push(line);
-        });
-    }).then(actual => {
-      // Back up the stderr in case the assertion fails.
-      const fullStderr = actual.stderr.map(item => `from child process: ${item}`);
-      const expected = { stderr: expectedStderr, code: 0, signal: null };
-
-      if (!expectedStderr) {
-        // If we don't care about stderr, delete it.
-        delete actual.stderr;
-        delete expected.stderr;
-      } else {
-        // Otherwise we only care about expected lines in the actual stderr, so
-        // filter out everything else.
-        actual.stderr = actual.stderr.filter(line => expectedStderr.includes(line));
-      }
-
-      assert.deepStrictEqual(actual, expected, `Assertion for child process test ${suite}.${testName} failed:${EOL}` + fullStderr.join(EOL));
-    });
-  });
-};

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 || 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 || 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,92 +0,0 @@
-/* eslint-disable no-eval */
-'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)`);
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  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,45 +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);
-}