ganach-cli 6.12.2

package/node_modules/node-addon-api/doc/value.md

@@ -0,0 +1,278 @@
+# Value
+
+`Napi::Value` is the C++ manifestation of a JavaScript value.
+
+Value is a the base class upon which other JavaScript values such as Number, Boolean, String, and Object are based.
+
+The following classes inherit, either directly or indirectly, from `Napi::Value`:
+
+- [`Napi::Array`](array.md)
+- [`Napi::ArrayBuffer`](array_buffer.md)
+- [`Napi::Boolean`](boolean.md)
+- [`Napi::Buffer`](buffer.md)
+- [`Napi::Date`](date.md)
+- [`Napi::External`](external.md)
+- [`Napi::Function`](function.md)
+- [`Napi::Name`](name.md)
+- [`Napi::Number`](number.md)
+- [`Napi::Object`](object.md)
+- [`Napi::String`](string.md)
+- [`Napi::Symbol`](symbol.md)
+- [`Napi::TypedArray`](typed_array.md)
+- [`Napi::TypedArrayOf`](typed_array_of.md)
+
+## Methods
+
+### Empty Constructor
+
+```cpp
+Napi::Value::Value();
+```
+
+Creates a new *empty* `Napi::Value` instance.
+
+### Constructor
+
+```cpp
+Napi::Value::Value(napi_env env, napi_value value);
+```
+
+- `[in] env`: The `napi_env` environment in which to construct the `Napi::Value` object.
+
+- `[in] value`: The C++ primitive from which to instantiate the `Napi::Value`. `value` may be any of:
+  - `bool`
+  - Any integer type
+  - Any floating point type
+  - `const char*` (encoded using UTF-8, null-terminated)
+  - `const char16_t*` (encoded using UTF-16-LE, null-terminated)
+  - `std::string` (encoded using UTF-8)
+  - `std::u16string`
+  - `Napi::Value`
+  - `napi_value`
+
+### From
+
+```cpp
+template <typename T> static Napi::Value Napi::Value::From(napi_env env, const T& value);
+```
+
+- `[in] env`: The `napi_env` environment in which to create the `Napi::Value` object.
+
+- `[in] value`: The N-API primitive value from which to create the `Napi::Value` object.
+
+Returns a `Napi::Value` object from an N-API primitive value.
+
+### operator napi_value
+
+```cpp
+operator napi_value() const;
+```
+
+Returns this Value's N-API value primitive.
+
+Returns `nullptr` if this `Napi::Value` is *empty*.
+
+### operator ==
+
+```cpp
+
+bool Napi::Value::operator ==(const Napi::Value& other) const;
+```
+
+- `[in] other`: The `Napi::Value` object to be compared.
+
+Returns a `bool` indicating if this `Napi::Value` strictly equals another `Napi::Value`.
+
+### operator !=
+
+```cpp
+bool Napi::Value::operator !=(const Napi::Value& other) const;
+```
+
+- `[in] other`: The `Napi::Value` object to be compared.
+
+Returns a `bool` indicating if this `Napi::Value` does not strictly equal another `Napi::Value`.
+
+### StrictEquals
+
+```cpp
+bool Napi::Value::StrictEquals(const Napi::Value& other) const;
+```
+- `[in] other`: The `Napi::Value` object to be compared.
+
+Returns a `bool` indicating if this `Napi::Value` strictly equals another `Napi::Value`.
+
+### Env
+
+```cpp
+Napi::Env Napi::Value::Env() const;
+```
+
+Returns the `Napi::Env` environment this value is associated with.
+
+### IsEmpty
+
+```cpp
+bool Napi::Value::IsEmpty() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is *empty* (uninitialized).
+
+An empty `Napi::Value` is invalid, and most attempts to perform an operation on an empty Value will result in an exception.
+Note an empty `Napi::Value` is distinct from JavaScript `null` or `undefined`, which are valid values.
+
+When C++ exceptions are disabled at compile time, a method with a `Napi::Value` return type may return an empty Value to indicate a pending exception. So when not using C++ exceptions, callers should check whether this `Napi::Value` is empty before attempting to use it.
+
+### Type
+
+```cpp
+napi_valuetype Napi::Value::Type() const;
+```
+
+Returns the `napi_valuetype` type of the `Napi::Value`.
+
+### IsUndefined
+
+```cpp
+bool Napi::Value::IsUndefined() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is an undefined JavaScript value.
+
+### IsNull
+
+```cpp
+bool Napi::Value::IsNull() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a null JavaScript value.
+
+### IsBoolean
+
+```cpp
+bool Napi::Value::IsBoolean() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript boolean.
+
+### IsNumber
+
+```cpp
+bool Napi::Value::IsNumber() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript number.
+
+### IsString
+
+```cpp
+bool Napi::Value::IsString() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript string.
+
+### IsSymbol
+
+```cpp
+bool Napi::Value::IsSymbol() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript symbol.
+
+### IsArray
+
+```cpp
+bool Napi::Value::IsArray() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript array.
+
+### IsArrayBuffer
+
+```cpp
+bool Napi::Value::IsArrayBuffer() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript array buffer.
+
+### IsTypedArray
+
+```cpp
+bool Napi::Value::IsTypedArray() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript typed array.
+
+### IsObject
+
+```cpp
+bool Napi::Value::IsObject() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is JavaScript object.
+
+### IsFunction
+
+```cpp
+bool Napi::Value::IsFunction() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript function.
+
+### IsBuffer
+
+```cpp
+bool Napi::Value::IsBuffer() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a Node buffer.
+
+### IsDate
+
+```cpp
+bool Napi::Value::IsDate() const;
+```
+
+Returns a `bool` indicating if this `Napi::Value` is a JavaScript date.
+
+### As
+
+```cpp
+template <typename T> T Napi::Value::As() const;
+```
+
+Casts to another type of `Napi::Value`, when the actual type is known or assumed.
+
+This conversion does not coerce the type. Calling any methods inappropriate for the actual value type will throw `Napi::Error`.
+
+### ToBoolean
+
+```cpp
+Napi::Boolean Napi::Value::ToBoolean() const;
+```
+
+Returns the `Napi::Value` coerced to a JavaScript boolean.
+
+### ToNumber
+
+```cpp
+Napi::Number Napi::Value::ToNumber() const;
+```
+
+Returns the `Napi::Value` coerced to a JavaScript number.
+
+### ToString
+
+```cpp
+Napi::String Napi::Value::ToString() const;
+```
+
+Returns the `Napi::Value` coerced to a JavaScript string.
+
+### ToObject
+
+```cpp
+Napi::Object Napi::Value::ToObject() const;
+```
+
+Returns the `Napi::Value` coerced to a JavaScript object.

package/node_modules/node-addon-api/doc/version_management.md

@@ -0,0 +1,43 @@
+# VersionManagement
+
+The `Napi::VersionManagement` class contains methods that allow information
+to be retrieved about the version of N-API and Node.js. In some cases it is
+important to make decisions based on different versions of the system.
+
+## Methods
+
+### GetNapiVersion
+
+Retrieves the highest N-API version supported by Node.js runtime.
+
+```cpp
+static uint32_t Napi::VersionManagement::GetNapiVersion(Env env);
+```
+
+- `[in] env`: The environment in which the API is invoked under.
+
+Returns the highest N-API version supported by Node.js runtime.
+
+### GetNodeVersion
+
+Retrives information about Node.js version present on the system. All the
+information is stored in the `napi_node_version` structrue that is defined as
+shown below:
+
+```cpp
+typedef struct {
+  uint32_t major;
+  uint32_t minor;
+  uint32_t patch;
+  const char* release;
+} napi_node_version;
+````
+
+```cpp
+static const napi_node_version* Napi::VersionManagement::GetNodeVersion(Env env);
+```
+
+- `[in] env`: The environment in which the API is invoked under.
+
+Returns the structure a pointer to the structure `napi_node_version` populated by
+the version information of Node.js runtime.

package/node_modules/node-addon-api/doc/working_with_javascript_values.md

@@ -0,0 +1,14 @@
+# Working with JavaScript Values
+
+`node-addon-api` provides a set of classes that allow to create and manage
+JavaScript object:
+
+- [Function](function.md)
+  - [FunctionReference](function_reference.md)
+- [ObjectWrap](object_wrap.md)
+  - [ClassPropertyDescriptor](class_property_descriptor.md)
+- [Buffer](buffer.md)
+- [ArrayBuffer](array_buffer.md)
+- [TypedArray](typed_array.md)
+  - [TypedArrayOf](typed_array_of.md)
+- [DataView](dataview.md)

package/node_modules/node-addon-api/external-napi/node_api.h

@@ -0,0 +1,7 @@
+#ifndef EXTERNAL_NODE_API_H_
+#define EXTERNAL_NODE_API_H_
+
+#define EXTERNAL_NAPI
+#include "../src/node_api.h"
+
+#endif

package/node_modules/node-addon-api/index.js

@@ -0,0 +1,45 @@
+var path = require('path');
+
+var versionArray = process.version
+  .substr(1)
+  .replace(/-.*$/, '')
+  .split('.')
+  .map(function(item) {
+    return +item;
+  });
+
+// TODO: Check if the main node semantic version is within multiple ranges,
+// or detect presence of built-in N-API by some other mechanism TBD.
+
+// We know which version of Node.js first shipped the incarnation of the API
+// available in *this* package. So, if we find that the Node.js version is below
+// that, we indicate that the API is missing from Node.js.
+var isNodeApiBuiltin = (
+  versionArray[0] > 8 ||
+  (versionArray[0] == 8 && versionArray[1] >= 6) ||
+  (versionArray[0] == 6 && versionArray[1] >= 15) ||
+  (versionArray[0] == 6 && versionArray[1] >= 14 && versionArray[2] >= 2));
+
+// The flag is not needed when the Node version is not 8, nor if the API is
+// built-in, because we removed the flag at the same time as creating the final
+// incarnation of the built-in API.
+var needsFlag = (!isNodeApiBuiltin && versionArray[0] == 8);
+
+var include = [__dirname];
+var gyp = path.join(__dirname, 'src', 'node_api.gyp');
+
+if (isNodeApiBuiltin) {
+  gyp += ':nothing';
+} else {
+  gyp += ':node-api';
+  include.unshift(path.join(__dirname, 'external-napi'));
+}
+
+module.exports = {
+  include: include.map(function(item) {
+    return '"' + item + '"';
+  }).join(' '),
+  gyp: gyp,
+  isNodeApiBuiltin: isNodeApiBuiltin,
+  needsFlag: needsFlag
+};

package/node_modules/node-addon-api/napi-inl.deprecated.h

@@ -0,0 +1,192 @@
+#ifndef SRC_NAPI_INL_DEPRECATED_H_
+#define SRC_NAPI_INL_DEPRECATED_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyDescriptor class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Getter>
+inline PropertyDescriptor
+PropertyDescriptor::Accessor(const char* utf8name,
+                             Getter getter,
+                             napi_property_attributes attributes,
+                             void* /*data*/) {
+  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ getter, nullptr });
+
+  return PropertyDescriptor({
+    utf8name,
+    nullptr,
+    nullptr,
+    CbData::Wrapper,
+    nullptr,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
+                                                       Getter getter,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  return Accessor(utf8name.c_str(), getter, attributes, data);
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
+                                                       Getter getter,
+                                                       napi_property_attributes attributes,
+                                                       void* /*data*/) {
+  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ getter, nullptr });
+
+  return PropertyDescriptor({
+    nullptr,
+    name,
+    nullptr,
+    CbData::Wrapper,
+    nullptr,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
+                                                       Getter getter,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(nameValue, getter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(const char* utf8name,
+                                                       Getter getter,
+                                                       Setter setter,
+                                                       napi_property_attributes attributes,
+                                                       void* /*data*/) {
+  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ getter, setter, nullptr });
+
+  return PropertyDescriptor({
+    utf8name,
+    nullptr,
+    nullptr,
+    CbData::GetterWrapper,
+    CbData::SetterWrapper,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
+                                                       Getter getter,
+                                                       Setter setter,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  return Accessor(utf8name.c_str(), getter, setter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
+                                                       Getter getter,
+                                                       Setter setter,
+                                                       napi_property_attributes attributes,
+                                                       void* /*data*/) {
+  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ getter, setter, nullptr });
+
+  return PropertyDescriptor({
+    nullptr,
+    name,
+    nullptr,
+    CbData::GetterWrapper,
+    CbData::SetterWrapper,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
+                                                       Getter getter,
+                                                       Setter setter,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(nameValue, getter, setter, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(const char* utf8name,
+                                                       Callable cb,
+                                                       napi_property_attributes attributes,
+                                                       void* /*data*/) {
+  typedef decltype(cb(CallbackInfo(nullptr, nullptr))) ReturnType;
+  typedef details::CallbackData<Callable, ReturnType> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ cb, nullptr });
+
+  return PropertyDescriptor({
+    utf8name,
+    nullptr,
+    CbData::Wrapper,
+    nullptr,
+    nullptr,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(const std::string& utf8name,
+                                                       Callable cb,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  return Function(utf8name.c_str(), cb, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(napi_value name,
+                                                       Callable cb,
+                                                       napi_property_attributes attributes,
+                                                       void* /*data*/) {
+  typedef decltype(cb(CallbackInfo(nullptr, nullptr))) ReturnType;
+  typedef details::CallbackData<Callable, ReturnType> CbData;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({ cb, nullptr });
+
+  return PropertyDescriptor({
+    nullptr,
+    name,
+    CbData::Wrapper,
+    nullptr,
+    nullptr,
+    nullptr,
+    attributes,
+    callbackData
+  });
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(Name name,
+                                                       Callable cb,
+                                                       napi_property_attributes attributes,
+                                                       void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Function(nameValue, cb, attributes, data);
+}
+
+#endif // !SRC_NAPI_INL_DEPRECATED_H_