@proteinjs/reflection-build 1.2.1 → 1.4.0

package/test/examples/source-repository/b/node_modules/nan/doc/new.md

@@ -1,147 +0,0 @@
-## New
-
-NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
-
- - <a href="#api_nan_new"><b><code>Nan::New()</code></b></a>
- - <a href="#api_nan_undefined"><b><code>Nan::Undefined()</code></b></a>
- - <a href="#api_nan_null"><b><code>Nan::Null()</code></b></a>
- - <a href="#api_nan_true"><b><code>Nan::True()</code></b></a>
- - <a href="#api_nan_false"><b><code>Nan::False()</code></b></a>
- - <a href="#api_nan_empty_string"><b><code>Nan::EmptyString()</code></b></a>
-
-
-<a name="api_nan_new"></a>
-### Nan::New()
-
-`Nan::New()` should be used to instantiate new JavaScript objects.
-
-Refer to the specific V8 type in the [V8 documentation](https://v8docs.nodesource.com/node-8.16/d1/d83/classv8_1_1_data.html) for information on the types of arguments required for instantiation.
-
-Signatures:
-
-Return types are mostly omitted from the signatures for simplicity. In most cases the type will be contained within a `v8::Local<T>`. The following types will be contained within a `Nan::MaybeLocal<T>`: `v8::String`, `v8::Date`, `v8::RegExp`, `v8::Script`, `v8::UnboundScript`.
-
-Empty objects:
-
-```c++
-Nan::New<T>();
-```
-
-Generic single and multiple-argument:
-
-```c++
-Nan::New<T>(A0 arg0);
-Nan::New<T>(A0 arg0, A1 arg1);
-Nan::New<T>(A0 arg0, A1 arg1, A2 arg2);
-Nan::New<T>(A0 arg0, A1 arg1, A2 arg2, A3 arg3);
-```
-
-For creating `v8::FunctionTemplate` and `v8::Function` objects:
-
-_The definition of `Nan::FunctionCallback` can be found in the [Method declaration](./methods.md#api_nan_method) documentation._
-
-```c++
-Nan::New<T>(Nan::FunctionCallback callback,
-            v8::Local<v8::Value> data = v8::Local<v8::Value>());
-Nan::New<T>(Nan::FunctionCallback callback,
-            v8::Local<v8::Value> data = v8::Local<v8::Value>(),
-            A2 a2 = A2());
-```
-
-Native number types:
-
-```c++
-v8::Local<v8::Boolean> Nan::New<T>(bool value);
-v8::Local<v8::Int32> Nan::New<T>(int32_t value);
-v8::Local<v8::Uint32> Nan::New<T>(uint32_t value);
-v8::Local<v8::Number> Nan::New<T>(double value);
-```
-
-String types:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::New<T>(std::string const& value);
-Nan::MaybeLocal<v8::String> Nan::New<T>(const char * value, int length);
-Nan::MaybeLocal<v8::String> Nan::New<T>(const char * value);
-Nan::MaybeLocal<v8::String> Nan::New<T>(const uint16_t * value);
-Nan::MaybeLocal<v8::String> Nan::New<T>(const uint16_t * value, int length);
-```
-
-Specialized types:
-
-```c++
-v8::Local<v8::String> Nan::New<T>(v8::String::ExternalStringResource * value);
-v8::Local<v8::String> Nan::New<T>(Nan::ExternalOneByteStringResource * value);
-v8::Local<v8::RegExp> Nan::New<T>(v8::Local<v8::String> pattern, v8::RegExp::Flags flags);
-```
-
-Note that `Nan::ExternalOneByteStringResource` maps to [`v8::String::ExternalOneByteStringResource`](https://v8docs.nodesource.com/node-8.16/d9/db3/classv8_1_1_string_1_1_external_one_byte_string_resource.html), and `v8::String::ExternalAsciiStringResource` in older versions of V8.
-
-
-<a name="api_nan_undefined"></a>
-### Nan::Undefined()
-
-A helper method to reference the `v8::Undefined` object in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Primitive> Nan::Undefined()
-```
-
-<a name="api_nan_null"></a>
-### Nan::Null()
-
-A helper method to reference the `v8::Null` object in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Primitive> Nan::Null()
-```
-
-<a name="api_nan_true"></a>
-### Nan::True()
-
-A helper method to reference the `v8::Boolean` object representing the `true` value in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Boolean> Nan::True()
-```
-
-<a name="api_nan_false"></a>
-### Nan::False()
-
-A helper method to reference the `v8::Boolean` object representing the `false` value in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Boolean> Nan::False()
-```
-
-<a name="api_nan_empty_string"></a>
-### Nan::EmptyString()
-
-Call [`v8::String::Empty`](https://v8docs.nodesource.com/node-8.16/d2/db3/classv8_1_1_string.html#a7c1bc8886115d7ee46f1d571dd6ebc6d) to reference the empty string in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::String> Nan::EmptyString()
-```
-
-
-<a name="api_nan_new_one_byte_string"></a>
-### Nan::NewOneByteString()
-
-An implementation of [`v8::String::NewFromOneByte()`](https://v8docs.nodesource.com/node-8.16/d2/db3/classv8_1_1_string.html#a5264d50b96d2c896ce525a734dc10f09) provided for consistent availability and API across supported versions of V8. Allocates a new string from Latin-1 data.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::NewOneByteString(const uint8_t * value,
-                                                  int length = -1)
-```

package/test/examples/source-repository/b/node_modules/nan/doc/node_misc.md

@@ -1,123 +0,0 @@
-## Miscellaneous Node Helpers
-
- - <a href="#api_nan_asyncresource"><b><code>Nan::AsyncResource</code></b></a>
- - <a href="#api_nan_make_callback"><b><code>Nan::MakeCallback()</code></b></a>
- - <a href="#api_nan_module_init"><b><code>NAN_MODULE_INIT()</code></b></a>
- - <a href="#api_nan_export"><b><code>Nan::Export()</code></b></a>
-
-<a name="api_nan_asyncresource"></a>
-### Nan::AsyncResource
-
-This class is analogous to the `AsyncResource` JavaScript class exposed by Node's [async_hooks][] API.
-
-When calling back into JavaScript asynchronously, special care must be taken to ensure that the runtime can properly track
-async hops. `Nan::AsyncResource` is a class that provides an RAII wrapper around `node::EmitAsyncInit`, `node::EmitAsyncDestroy`,
-and `node::MakeCallback`. Using this mechanism to call back into JavaScript, as opposed to `Nan::MakeCallback` or
-`v8::Function::Call` ensures that the callback is executed in the correct async context. This ensures that async mechanisms
-such as domains and [async_hooks][] function correctly.
-
-Definition:
-
-```c++
-class AsyncResource {
- public:
-  AsyncResource(v8::Local<v8::String> name,
-                v8::Local<v8::Object> resource = New<v8::Object>());
-  AsyncResource(const char* name,
-                v8::Local<v8::Object> resource = New<v8::Object>());
-  ~AsyncResource();
-
-  v8::MaybeLocal<v8::Value> runInAsyncScope(v8::Local<v8::Object> target,
-                                            v8::Local<v8::Function> func,
-                                            int argc,
-                                            v8::Local<v8::Value>* argv);
-  v8::MaybeLocal<v8::Value> runInAsyncScope(v8::Local<v8::Object> target,
-                                            v8::Local<v8::String> symbol,
-                                            int argc,
-                                            v8::Local<v8::Value>* argv);
-  v8::MaybeLocal<v8::Value> runInAsyncScope(v8::Local<v8::Object> target,
-                                            const char* method,
-                                            int argc,
-                                            v8::Local<v8::Value>* argv);
-};
-```
-
-* `name`: Identifier for the kind of resource that is being provided for diagnostics information exposed by the [async_hooks][]
-  API. This will be passed to the possible `init` hook as the `type`. To avoid name collisions with other modules we recommend
-  that the name include the name of the owning module as a prefix. For example `mysql` module could use something like
-  `mysql:batch-db-query-resource`.
-* `resource`: An optional object associated with the async work that will be passed to the possible [async_hooks][]
-  `init` hook. If this parameter is omitted, or an empty handle is provided, this object will be created automatically.
-* When calling JS on behalf of this resource, one can use `runInAsyncScope`. This will ensure that the callback runs in the
-  correct async execution context.
-* `AsyncDestroy` is automatically called when an AsyncResource object is destroyed.
-
-For more details, see the Node [async_hooks][] documentation. You might also want to take a look at the documentation for the
-[N-API counterpart][napi]. For example usage, see the `asyncresource.cpp` example in the `test/cpp` directory.
-
-<a name="api_nan_make_callback"></a>
-### Nan::MakeCallback()
-
-Deprecated wrappers around the legacy `node::MakeCallback()` APIs. Node.js 10+
-has deprecated these legacy APIs as they do not provide a mechanism to preserve
-async context.
-
-We recommend that you use the `AsyncResource` class and `AsyncResource::runInAsyncScope` instead of using `Nan::MakeCallback` or
-`v8::Function#Call()` directly. `AsyncResource` properly takes care of running the callback in the correct async execution
-context – something that is essential for functionality like domains, async_hooks and async debugging.
-
-Signatures:
-
-```c++
-NAN_DEPRECATED
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       v8::Local<v8::Function> func,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-NAN_DEPRECATED
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       v8::Local<v8::String> symbol,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-NAN_DEPRECATED
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       const char* method,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-```
-
-
-<a name="api_nan_module_init"></a>
-### NAN_MODULE_INIT()
-
-Used to define the entry point function to a Node add-on. Creates a function with a given `name` that receives a `target` object representing the equivalent of the JavaScript `exports` object.
-
-See example below.
-
-<a name="api_nan_export"></a>
-### Nan::Export()
-
-A simple helper to register a `v8::FunctionTemplate` from a JavaScript-accessible method (see [Methods](./methods.md)) as a property on an object. Can be used in a way similar to assigning properties to `module.exports` in JavaScript.
-
-Signature:
-
-```c++
-void Export(v8::Local<v8::Object> target, const char *name, Nan::FunctionCallback f)
-```
-
-Also available as the shortcut `NAN_EXPORT` macro.
-
-Example:
-
-```c++
-NAN_METHOD(Foo) {
-  ...
-}
-
-NAN_MODULE_INIT(Init) {
-  NAN_EXPORT(target, Foo);
-}
-```
-
-[async_hooks]: https://nodejs.org/dist/latest-v9.x/docs/api/async_hooks.html
-[napi]: https://nodejs.org/dist/latest-v9.x/docs/api/n-api.html#n_api_custom_asynchronous_operations

package/test/examples/source-repository/b/node_modules/nan/doc/object_wrappers.md

@@ -1,263 +0,0 @@
-## Object Wrappers
-
-The `ObjectWrap` class can be used to make wrapped C++ objects and a factory of wrapped objects.
-
- - <a href="#api_nan_object_wrap"><b><code>Nan::ObjectWrap</code></b></a>
-
-
-<a name="api_nan_object_wrap"></a>
-### Nan::ObjectWrap()
-
-A reimplementation of `node::ObjectWrap` that adds some API not present in older versions of Node. Should be preferred over `node::ObjectWrap` in all cases for consistency.
-
-Definition:
-
-```c++
-class ObjectWrap {
- public:
-  ObjectWrap();
-
-  virtual ~ObjectWrap();
-
-  template <class T>
-  static inline T* Unwrap(v8::Local<v8::Object> handle);
-
-  inline v8::Local<v8::Object> handle();
-
-  inline Nan::Persistent<v8::Object>& persistent();
-
- protected:
-  inline void Wrap(v8::Local<v8::Object> handle);
-
-  inline void MakeWeak();
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref();
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistent handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref();
-
-  int refs_;  // ro
-};
-```
-
-See the Node documentation on [Wrapping C++ Objects](https://nodejs.org/api/addons.html#addons_wrapping_c_objects) for more details.
-
-### This vs. Holder
-
-When calling `Unwrap`, it is important that the argument is indeed some JavaScript object which got wrapped by a `Wrap` call for this class or any derived class.
-The `Signature` installed by [`Nan::SetPrototypeMethod()`](methods.md#api_nan_set_prototype_method) does ensure that `info.Holder()` is just such an instance.
-In Node 0.12 and later, `info.This()` will also be of such a type, since otherwise the invocation will get rejected.
-However, in Node 0.10 and before it was possible to invoke a method on a JavaScript object which just had the extension type in its prototype chain.
-In such a situation, calling `Unwrap` on `info.This()` will likely lead to a failed assertion causing a crash, but could lead to even more serious corruption.
-
-On the other hand, calling `Unwrap` in an [accessor](methods.md#api_nan_set_accessor) should not use `Holder()` if the accessor is defined on the prototype.
-So either define your accessors on the instance template,
-or use `This()` after verifying that it is indeed a valid object.
-
-### Examples
-
-#### Basic
-
-```c++
-class MyObject : public Nan::ObjectWrap {
- public:
-  static NAN_MODULE_INIT(Init) {
-    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
-    tpl->SetClassName(Nan::New("MyObject").ToLocalChecked());
-    tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-    Nan::SetPrototypeMethod(tpl, "getHandle", GetHandle);
-    Nan::SetPrototypeMethod(tpl, "getValue", GetValue);
-
-    constructor().Reset(Nan::GetFunction(tpl).ToLocalChecked());
-    Nan::Set(target, Nan::New("MyObject").ToLocalChecked(),
-      Nan::GetFunction(tpl).ToLocalChecked());
-  }
-
- private:
-  explicit MyObject(double value = 0) : value_(value) {}
-  ~MyObject() {}
-
-  static NAN_METHOD(New) {
-    if (info.IsConstructCall()) {
-      double value = info[0]->IsUndefined() ? 0 : Nan::To<double>(info[0]).FromJust();
-      MyObject *obj = new MyObject(value);
-      obj->Wrap(info.This());
-      info.GetReturnValue().Set(info.This());
-    } else {
-      const int argc = 1;
-      v8::Local<v8::Value> argv[argc] = {info[0]};
-      v8::Local<v8::Function> cons = Nan::New(constructor());
-      info.GetReturnValue().Set(Nan::NewInstance(cons, argc, argv).ToLocalChecked());
-    }
-  }
-
-  static NAN_METHOD(GetHandle) {
-    MyObject* obj = Nan::ObjectWrap::Unwrap<MyObject>(info.Holder());
-    info.GetReturnValue().Set(obj->handle());
-  }
-
-  static NAN_METHOD(GetValue) {
-    MyObject* obj = Nan::ObjectWrap::Unwrap<MyObject>(info.Holder());
-    info.GetReturnValue().Set(obj->value_);
-  }
-
-  static inline Nan::Persistent<v8::Function> & constructor() {
-    static Nan::Persistent<v8::Function> my_constructor;
-    return my_constructor;
-  }
-
-  double value_;
-};
-
-NODE_MODULE(objectwrapper, MyObject::Init)
-```
-
-To use in Javascript:
-
-```Javascript
-var objectwrapper = require('bindings')('objectwrapper');
-
-var obj = new objectwrapper.MyObject(5);
-console.log('Should be 5: ' + obj.getValue());
-```
-
-#### Factory of wrapped objects
-
-```c++
-class MyFactoryObject : public Nan::ObjectWrap {
- public:
-  static NAN_MODULE_INIT(Init) {
-    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
-    tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-    Nan::SetPrototypeMethod(tpl, "getValue", GetValue);
-
-    constructor().Reset(Nan::GetFunction(tpl).ToLocalChecked());
-  }
-
-  static NAN_METHOD(NewInstance) {
-    v8::Local<v8::Function> cons = Nan::New(constructor());
-    double value = info[0]->IsNumber() ? Nan::To<double>(info[0]).FromJust() : 0;
-    const int argc = 1;
-    v8::Local<v8::Value> argv[1] = {Nan::New(value)};
-    info.GetReturnValue().Set(Nan::NewInstance(cons, argc, argv).ToLocalChecked());
-  }
-
-  // Needed for the next example:
-  inline double value() const {
-    return value_;
-  }
-
- private:
-  explicit MyFactoryObject(double value = 0) : value_(value) {}
-  ~MyFactoryObject() {}
-
-  static NAN_METHOD(New) {
-    if (info.IsConstructCall()) {
-      double value = info[0]->IsNumber() ? Nan::To<double>(info[0]).FromJust() : 0;
-      MyFactoryObject * obj = new MyFactoryObject(value);
-      obj->Wrap(info.This());
-      info.GetReturnValue().Set(info.This());
-    } else {
-      const int argc = 1;
-      v8::Local<v8::Value> argv[argc] = {info[0]};
-      v8::Local<v8::Function> cons = Nan::New(constructor());
-      info.GetReturnValue().Set(Nan::NewInstance(cons, argc, argv).ToLocalChecked());
-    }
-  }
-
-  static NAN_METHOD(GetValue) {
-    MyFactoryObject* obj = ObjectWrap::Unwrap<MyFactoryObject>(info.Holder());
-    info.GetReturnValue().Set(obj->value_);
-  }
-
-  static inline Nan::Persistent<v8::Function> & constructor() {
-    static Nan::Persistent<v8::Function> my_constructor;
-    return my_constructor;
-  }
-
-  double value_;
-};
-
-NAN_MODULE_INIT(Init) {
-  MyFactoryObject::Init(target);
-  Nan::Set(target,
-    Nan::New<v8::String>("newFactoryObjectInstance").ToLocalChecked(),
-    Nan::GetFunction(
-      Nan::New<v8::FunctionTemplate>(MyFactoryObject::NewInstance)).ToLocalChecked()
-  );
-}
-
-NODE_MODULE(wrappedobjectfactory, Init)
-```
-
-To use in Javascript:
-
-```Javascript
-var wrappedobjectfactory = require('bindings')('wrappedobjectfactory');
-
-var obj = wrappedobjectfactory.newFactoryObjectInstance(10);
-console.log('Should be 10: ' + obj.getValue());
-```
-
-#### Passing wrapped objects around
-
-Use the `MyFactoryObject` class above along with the following:
-
-```c++
-static NAN_METHOD(Sum) {
-  Nan::MaybeLocal<v8::Object> maybe1 = Nan::To<v8::Object>(info[0]);
-  Nan::MaybeLocal<v8::Object> maybe2 = Nan::To<v8::Object>(info[1]);
-
-  // Quick check:
-  if (maybe1.IsEmpty() || maybe2.IsEmpty()) {
-    // return value is undefined by default
-    return;
-  }
-
-  MyFactoryObject* obj1 =
-    Nan::ObjectWrap::Unwrap<MyFactoryObject>(maybe1.ToLocalChecked());
-  MyFactoryObject* obj2 =
-    Nan::ObjectWrap::Unwrap<MyFactoryObject>(maybe2.ToLocalChecked());
-
-  info.GetReturnValue().Set(Nan::New<v8::Number>(obj1->value() + obj2->value()));
-}
-
-NAN_MODULE_INIT(Init) {
-  MyFactoryObject::Init(target);
-  Nan::Set(target,
-    Nan::New<v8::String>("newFactoryObjectInstance").ToLocalChecked(),
-    Nan::GetFunction(
-      Nan::New<v8::FunctionTemplate>(MyFactoryObject::NewInstance)).ToLocalChecked()
-  );
-  Nan::Set(target,
-    Nan::New<v8::String>("sum").ToLocalChecked(),
-    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(Sum)).ToLocalChecked()
-  );
-}
-
-NODE_MODULE(myaddon, Init)
-```
-
-To use in Javascript:
-
-```Javascript
-var myaddon = require('bindings')('myaddon');
-
-var obj1 = myaddon.newFactoryObjectInstance(5);
-var obj2 = myaddon.newFactoryObjectInstance(10);
-console.log('sum of object values: ' + myaddon.sum(obj1, obj2));
-```