codexui-android 0.1.94 → 0.1.96

package/node_modules/nan/doc/asyncworker.md

@@ -1,146 +0,0 @@
-## Asynchronous work helpers
-
-`Nan::AsyncWorker`, `Nan::AsyncProgressWorker` and `Nan::AsyncProgressQueueWorker` are helper classes that make working with asynchronous code easier.
-
- - <a href="#api_nan_async_worker"><b><code>Nan::AsyncWorker</code></b></a>
- - <a href="#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorkerBase &amp; Nan::AsyncProgressWorker</code></b></a>
- - <a href="#api_nan_async_progress_queue_worker"><b><code>Nan::AsyncProgressQueueWorker</code></b></a>
- - <a href="#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
-
-<a name="api_nan_async_worker"></a>
-### Nan::AsyncWorker
-
-`Nan::AsyncWorker` is an _abstract_ class that you can subclass to have much of the annoying asynchronous queuing and handling taken care of for you. It can even store arbitrary V8 objects for you and have them persist while the asynchronous work is in progress.
-
-This class internally handles the details of creating an [`AsyncResource`][AsyncResource], and running the callback in the
-correct async context. To be able to identify the async resources created by this class in async-hooks, provide a
-`resource_name` to the constructor. It is recommended that the module name be used as a prefix to the `resource_name` to avoid
-collisions in the names. For more details see [`AsyncResource`][AsyncResource] documentation.  The `resource_name` needs to stay valid for the lifetime of the worker instance.
-
-Definition:
-
-```c++
-class AsyncWorker {
- public:
-  explicit AsyncWorker(Callback *callback_, const char* resource_name = "nan:AsyncWorker");
-
-  virtual ~AsyncWorker();
-
-  virtual void WorkComplete();
-
-  void SaveToPersistent(const char *key, const v8::Local<v8::Value> &value);
-
-  void SaveToPersistent(const v8::Local<v8::String> &key,
-                        const v8::Local<v8::Value> &value);
-
-  void SaveToPersistent(uint32_t index,
-                        const v8::Local<v8::Value> &value);
-
-  v8::Local<v8::Value> GetFromPersistent(const char *key) const;
-
-  v8::Local<v8::Value> GetFromPersistent(const v8::Local<v8::String> &key) const;
-
-  v8::Local<v8::Value> GetFromPersistent(uint32_t index) const;
-
-  virtual void Execute() = 0;
-
-  uv_work_t request;
-
-  virtual void Destroy();
-
- protected:
-  Persistent<v8::Object> persistentHandle;
-
-  Callback *callback;
-
-  virtual void HandleOKCallback();
-
-  virtual void HandleErrorCallback();
-
-  void SetErrorMessage(const char *msg);
-
-  const char* ErrorMessage();
-};
-```
-
-<a name="api_nan_async_progress_worker"></a>
-### Nan::AsyncProgressWorkerBase &amp; Nan::AsyncProgressWorker
-
-`Nan::AsyncProgressWorkerBase` is an _abstract_ class template that extends `Nan::AsyncWorker` and adds additional progress reporting callbacks that can be used during the asynchronous work execution to provide progress data back to JavaScript.
-
-Previously the definition of `Nan::AsyncProgressWorker` only allowed sending `const char` data. Now extending `Nan::AsyncProgressWorker` will yield an instance of the implicit `Nan::AsyncProgressWorkerBase` template with type `<char>` for compatibility.
-
-`Nan::AsyncProgressWorkerBase` &amp; `Nan::AsyncProgressWorker` is intended for best-effort delivery of nonessential progress messages, e.g. a progress bar.  The last event sent before the main thread is woken will be delivered.
-
-Definition:
-
-```c++
-template<class T>
-class AsyncProgressWorkerBase<T> : public AsyncWorker {
- public:
-  explicit AsyncProgressWorkerBase(Callback *callback_, const char* resource_name = ...);
-
-  virtual ~AsyncProgressWorkerBase();
-
-  void WorkProgress();
-
-  class ExecutionProgress {
-   public:
-    void Signal() const;
-    void Send(const T* data, size_t count) const;
-  };
-
-  virtual void Execute(const ExecutionProgress& progress) = 0;
-
-  virtual void HandleProgressCallback(const T *data, size_t count) = 0;
-
-  virtual void Destroy();
-};
-
-typedef AsyncProgressWorkerBase<T> AsyncProgressWorker;
-```
-
-<a name="api_nan_async_progress_queue_worker"></a>
-### Nan::AsyncProgressQueueWorker
-
-`Nan::AsyncProgressQueueWorker` is an _abstract_ class template that extends `Nan::AsyncWorker` and adds additional progress reporting callbacks that can be used during the asynchronous work execution to provide progress data back to JavaScript.
-
-`Nan::AsyncProgressQueueWorker` behaves exactly the same as `Nan::AsyncProgressWorker`, except all events are queued and delivered to the main thread.
-
-Definition:
-
-```c++
-template<class T>
-class AsyncProgressQueueWorker<T> : public AsyncWorker {
- public:
-  explicit AsyncProgressQueueWorker(Callback *callback_, const char* resource_name = "nan:AsyncProgressQueueWorker");
-
-  virtual ~AsyncProgressQueueWorker();
-
-  void WorkProgress();
-
-  class ExecutionProgress {
-   public:
-    void Send(const T* data, size_t count) const;
-  };
-
-  virtual void Execute(const ExecutionProgress& progress) = 0;
-
-  virtual void HandleProgressCallback(const T *data, size_t count) = 0;
-
-  virtual void Destroy();
-};
-```
-
-<a name="api_nan_async_queue_worker"></a>
-### Nan::AsyncQueueWorker
-
-`Nan::AsyncQueueWorker` will run a `Nan::AsyncWorker` asynchronously via libuv. Both the `execute` and `after_work` steps are taken care of for you. Most of the logic for this is embedded in `Nan::AsyncWorker`.
-
-Definition:
-
-```c++
-void AsyncQueueWorker(AsyncWorker *);
-```
-
-[AsyncResource]: node_misc.md#api_nan_asyncresource

package/node_modules/nan/doc/buffers.md

@@ -1,54 +0,0 @@
-## Buffers
-
-NAN's `node::Buffer` helpers exist as the API has changed across supported Node versions. Use these methods to ensure compatibility.
-
- - <a href="#api_nan_new_buffer"><b><code>Nan::NewBuffer()</code></b></a>
- - <a href="#api_nan_copy_buffer"><b><code>Nan::CopyBuffer()</code></b></a>
- - <a href="#api_nan_free_callback"><b><code>Nan::FreeCallback()</code></b></a>
-
-<a name="api_nan_new_buffer"></a>
-### Nan::NewBuffer()
-
-Allocate a new `node::Buffer` object with the specified size and optional data. Calls `node::Buffer::New()`.
-
-Note that when creating a `Buffer` using `Nan::NewBuffer()` and an existing `char*`, it is assumed that the ownership of the pointer is being transferred to the new `Buffer` for management.
-When a `node::Buffer` instance is garbage collected and a `FreeCallback` has not been specified, `data` will be disposed of via a call to `free()`.
-You _must not_ free the memory space manually once you have created a `Buffer` in this way.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(uint32_t size)
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char* data, uint32_t size)
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char *data,
-                                           size_t length,
-                                           Nan::FreeCallback callback,
-                                           void *hint)
-```
-
-
-<a name="api_nan_copy_buffer"></a>
-### Nan::CopyBuffer()
-
-Similar to [`Nan::NewBuffer()`](#api_nan_new_buffer) except that an implicit memcpy will occur within Node. Calls `node::Buffer::Copy()`.
-
-Management of the `char*` is left to the user, you should manually free the memory space if necessary as the new `Buffer` will have its own copy.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::CopyBuffer(const char *data, uint32_t size)
-```
-
-
-<a name="api_nan_free_callback"></a>
-### Nan::FreeCallback()
-
-A free callback that can be provided to [`Nan::NewBuffer()`](#api_nan_new_buffer).
-The supplied callback will be invoked when the `Buffer` undergoes garbage collection.
-
-Signature:
-
-```c++
-typedef void (*FreeCallback)(char *data, void *hint);
-```

package/node_modules/nan/doc/callback.md

@@ -1,76 +0,0 @@
-## Nan::Callback
-
-`Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
-
- - <a href="#api_nan_callback"><b><code>Nan::Callback</code></b></a>
-
-<a name="api_nan_callback"></a>
-### Nan::Callback
-
-```c++
-class Callback {
- public:
-  Callback();
-
-  explicit Callback(const v8::Local<v8::Function> &fn);
-
-  ~Callback();
-
-  bool operator==(const Callback &other) const;
-
-  bool operator!=(const Callback &other) const;
-
-  v8::Local<v8::Function> operator*() const;
-
-  MaybeLocal<v8::Value> operator()(AsyncResource* async_resource,
-                                   v8::Local<v8::Object> target,
-                                   int argc = 0,
-                                   v8::Local<v8::Value> argv[] = 0) const;
-
-  MaybeLocal<v8::Value> operator()(AsyncResource* async_resource,
-                                   int argc = 0,
-                                   v8::Local<v8::Value> argv[] = 0) const;
-
-  void SetFunction(const v8::Local<v8::Function> &fn);
-
-  v8::Local<v8::Function> GetFunction() const;
-
-  bool IsEmpty() const;
-
-  void Reset(const v8::Local<v8::Function> &fn);
-
-  void Reset();
-
-  MaybeLocal<v8::Value> Call(v8::Local<v8::Object> target,
-                            int argc,
-                            v8::Local<v8::Value> argv[],
-                            AsyncResource* async_resource) const;
-  MaybeLocal<v8::Value> Call(int argc,
-                             v8::Local<v8::Value> argv[],
-                             AsyncResource* async_resource) const;
-
-  // Deprecated versions. Use the versions that accept an async_resource instead
-  // as they run the callback in the correct async context as specified by the
-  // resource. If you want to call a synchronous JS function (i.e. on a
-  // non-empty JS stack), you can use Nan::Call instead.
-  v8::Local<v8::Value> operator()(v8::Local<v8::Object> target,
-                                  int argc = 0,
-                                  v8::Local<v8::Value> argv[] = 0) const;
-
-  v8::Local<v8::Value> operator()(int argc = 0,
-                                  v8::Local<v8::Value> argv[] = 0) const;
-  v8::Local<v8::Value> Call(v8::Local<v8::Object> target,
-                            int argc,
-                            v8::Local<v8::Value> argv[]) const;
-
-  v8::Local<v8::Value> Call(int argc, v8::Local<v8::Value> argv[]) const;
-};
-```
-
-Example usage:
-
-```c++
-v8::Local<v8::Function> function;
-Nan::Callback callback(function);
-callback.Call(0, 0);
-```

package/node_modules/nan/doc/converters.md

@@ -1,41 +0,0 @@
-## Converters
-
-NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
-
- - <a href="#api_nan_to"><b><code>Nan::To()</code></b></a>
-
-<a name="api_nan_to"></a>
-### Nan::To()
-
-Converts a `v8::Local<v8::Value>` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
-
-See [maybe_types.md](./maybe_types.md) for more information on `Nan::Maybe` types.
-
-Signatures:
-
-```c++
-// V8 types
-Nan::MaybeLocal<v8::Boolean> Nan::To<v8::Boolean>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Int32> Nan::To<v8::Int32>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Integer> Nan::To<v8::Integer>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Object> Nan::To<v8::Object>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Number> Nan::To<v8::Number>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::String> Nan::To<v8::String>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Uint32> Nan::To<v8::Uint32>(v8::Local<v8::Value> val);
-
-// Native types
-Nan::Maybe<bool> Nan::To<bool>(v8::Local<v8::Value> val);
-Nan::Maybe<double> Nan::To<double>(v8::Local<v8::Value> val);
-Nan::Maybe<int32_t> Nan::To<int32_t>(v8::Local<v8::Value> val);
-Nan::Maybe<int64_t> Nan::To<int64_t>(v8::Local<v8::Value> val);
-Nan::Maybe<uint32_t> Nan::To<uint32_t>(v8::Local<v8::Value> val);
-```
-
-### Example
-
-```c++
-v8::Local<v8::Value> val;
-Nan::MaybeLocal<v8::String> str = Nan::To<v8::String>(val);
-Nan::Maybe<double> d = Nan::To<double>(val);
-```
-

package/node_modules/nan/doc/errors.md

@@ -1,226 +0,0 @@
-## Errors
-
-NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
-
-Note that an Error object is simply a specialized form of `v8::Value`.
-
-Also consult the V8 Embedders Guide section on [Exceptions](https://v8.dev/docs/embed#exceptions) for more information.
-
- - <a href="#api_nan_error"><b><code>Nan::Error()</code></b></a>
- - <a href="#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
- - <a href="#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
- - <a href="#api_nan_syntax_error"><b><code>Nan::SyntaxError()</code></b></a>
- - <a href="#api_nan_type_error"><b><code>Nan::TypeError()</code></b></a>
- - <a href="#api_nan_throw_error"><b><code>Nan::ThrowError()</code></b></a>
- - <a href="#api_nan_throw_range_error"><b><code>Nan::ThrowRangeError()</code></b></a>
- - <a href="#api_nan_throw_reference_error"><b><code>Nan::ThrowReferenceError()</code></b></a>
- - <a href="#api_nan_throw_syntax_error"><b><code>Nan::ThrowSyntaxError()</code></b></a>
- - <a href="#api_nan_throw_type_error"><b><code>Nan::ThrowTypeError()</code></b></a>
- - <a href="#api_nan_fatal_exception"><b><code>Nan::FatalException()</code></b></a>
- - <a href="#api_nan_errno_exception"><b><code>Nan::ErrnoException()</code></b></a>
- - <a href="#api_nan_try_catch"><b><code>Nan::TryCatch</code></b></a>
-
-
-<a name="api_nan_error"></a>
-### Nan::Error()
-
-Create a new Error object using the [v8::Exception](https://v8docs.nodesource.com/node-8.16/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an Error object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::Error(const char *msg);
-v8::Local<v8::Value> Nan::Error(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_range_error"></a>
-### Nan::RangeError()
-
-Create a new RangeError object using the [v8::Exception](https://v8docs.nodesource.com/node-8.16/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an RangeError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::RangeError(const char *msg);
-v8::Local<v8::Value> Nan::RangeError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_reference_error"></a>
-### Nan::ReferenceError()
-
-Create a new ReferenceError object using the [v8::Exception](https://v8docs.nodesource.com/node-8.16/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an ReferenceError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::ReferenceError(const char *msg);
-v8::Local<v8::Value> Nan::ReferenceError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_syntax_error"></a>
-### Nan::SyntaxError()
-
-Create a new SyntaxError object using the [v8::Exception](https://v8docs.nodesource.com/node-8.16/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an SyntaxError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::SyntaxError(const char *msg);
-v8::Local<v8::Value> Nan::SyntaxError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_type_error"></a>
-### Nan::TypeError()
-
-Create a new TypeError object using the [v8::Exception](https://v8docs.nodesource.com/node-8.16/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an TypeError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::TypeError(const char *msg);
-v8::Local<v8::Value> Nan::TypeError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_throw_error"></a>
-### Nan::ThrowError()
-
-Throw an Error object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new Error object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowError(const char *msg);
-void Nan::ThrowError(v8::Local<v8::String> msg);
-void Nan::ThrowError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_range_error"></a>
-### Nan::ThrowRangeError()
-
-Throw an RangeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new RangeError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowRangeError(const char *msg);
-void Nan::ThrowRangeError(v8::Local<v8::String> msg);
-void Nan::ThrowRangeError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_reference_error"></a>
-### Nan::ThrowReferenceError()
-
-Throw an ReferenceError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new ReferenceError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowReferenceError(const char *msg);
-void Nan::ThrowReferenceError(v8::Local<v8::String> msg);
-void Nan::ThrowReferenceError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_syntax_error"></a>
-### Nan::ThrowSyntaxError()
-
-Throw an SyntaxError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new SyntaxError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowSyntaxError(const char *msg);
-void Nan::ThrowSyntaxError(v8::Local<v8::String> msg);
-void Nan::ThrowSyntaxError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_type_error"></a>
-### Nan::ThrowTypeError()
-
-Throw an TypeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new TypeError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowTypeError(const char *msg);
-void Nan::ThrowTypeError(v8::Local<v8::String> msg);
-void Nan::ThrowTypeError(v8::Local<v8::Value> error);
-```
-
-<a name="api_nan_fatal_exception"></a>
-### Nan::FatalException()
-
-Replaces `node::FatalException()` which has a different API across supported versions of Node. For use with [`Nan::TryCatch`](#api_nan_try_catch).
-
-Signature:
-
-```c++
-void Nan::FatalException(const Nan::TryCatch& try_catch);
-```
-
-<a name="api_nan_errno_exception"></a>
-### Nan::ErrnoException()
-
-Replaces `node::ErrnoException()` which has a different API across supported versions of Node. 
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::ErrnoException(int errorno,
-                                         const char* syscall = NULL,
-                                         const char* message = NULL,
-                                         const char* path = NULL);
-```
-
-
-<a name="api_nan_try_catch"></a>
-### Nan::TryCatch
-
-A simple wrapper around [`v8::TryCatch`](https://v8docs.nodesource.com/node-8.16/d4/dc6/classv8_1_1_try_catch.html) compatible with all supported versions of V8. Can be used as a direct replacement in most cases. See also [`Nan::FatalException()`](#api_nan_fatal_exception) for an internal use compatible with `node::FatalException`.
-
-Signature:
-
-```c++
-class Nan::TryCatch {
- public:
-  Nan::TryCatch();
-
-  bool HasCaught() const;
-
-  bool CanContinue() const;
-
-  v8::Local<v8::Value> ReThrow();
-
-  v8::Local<v8::Value> Exception() const;
-
-  // Nan::MaybeLocal for older versions of V8
-  v8::MaybeLocal<v8::Value> StackTrace() const;
-
-  v8::Local<v8::Message> Message() const;
-
-  void Reset();
-
-  void SetVerbose(bool value);
-
-  void SetCaptureMessage(bool value);
-};
-```
-

package/node_modules/nan/doc/json.md

@@ -1,62 +0,0 @@
-## JSON
-
-The _JSON_ object provides the C++ versions of the methods offered by the `JSON` object in javascript. V8 exposes these methods via the `v8::JSON` object.
-
- - <a href="#api_nan_json_parse"><b><code>Nan::JSON.Parse</code></b></a>
- - <a href="#api_nan_json_stringify"><b><code>Nan::JSON.Stringify</code></b></a>
-
-Refer to the V8 JSON object in the [V8 documentation](https://v8docs.nodesource.com/node-8.16/da/d6f/classv8_1_1_j_s_o_n.html) for more information about these methods and their arguments.
-
-<a name="api_nan_json_parse"></a>
-
-### Nan::JSON.Parse
-
-A simple wrapper around [`v8::JSON::Parse`](https://v8docs.nodesource.com/node-8.16/da/d6f/classv8_1_1_j_s_o_n.html#a936310d2540fb630ed37d3ee3ffe4504).
-
-Definition:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::JSON::Parse(v8::Local<v8::String> json_string);
-```
-
-Use `JSON.Parse(json_string)` to parse a string into a `v8::Value`.
-
-Example:
-
-```c++
-v8::Local<v8::String> json_string = Nan::New("{ \"JSON\": \"object\" }").ToLocalChecked();
-
-Nan::JSON NanJSON;
-Nan::MaybeLocal<v8::Value> result = NanJSON.Parse(json_string);
-if (!result.IsEmpty()) {
-  v8::Local<v8::Value> val = result.ToLocalChecked();
-}
-```
-
-<a name="api_nan_json_stringify"></a>
-
-### Nan::JSON.Stringify
-
-A simple wrapper around [`v8::JSON::Stringify`](https://v8docs.nodesource.com/node-8.16/da/d6f/classv8_1_1_j_s_o_n.html#a44b255c3531489ce43f6110209138860).
-
-Definition:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::JSON::Stringify(v8::Local<v8::Object> json_object, v8::Local<v8::String> gap = v8::Local<v8::String>());
-```
-
-Use `JSON.Stringify(value)` to stringify a `v8::Object`.
-
-Example:
-
-```c++
-// using `v8::Local<v8::Value> val` from the `JSON::Parse` example
-v8::Local<v8::Object> obj = Nan::To<v8::Object>(val).ToLocalChecked();
-
-Nan::JSON NanJSON;
-Nan::MaybeLocal<v8::String> result = NanJSON.Stringify(obj);
-if (!result.IsEmpty()) {
-  v8::Local<v8::String> stringified = result.ToLocalChecked();
-}
-```
-