#include <node_buffer.h>

#include <node_object_wrap.h>

#include <limits.h> // INT_MAX

#include <string.h>

#include <algorithm>

#include <cmath>

#include <vector>

#define NAPI_EXPERIMENTAL

#include "node_api.h"

#include "node_internals.h"

#include "env.h"

napi_status napi_set_last_error(napi_env env, napi_status error_code,

uint32_t engine_error_code = 0,

void* engine_reserved = nullptr);

napi_status napi_clear_last_error(napi_env env);

struct napi_env__ {

};

#define NAPI_PRIVATE_KEY(context, suffix) \

(node::Environment::GetCurrent((context))->napi_ ## suffix())

#define RETURN_STATUS_IF_FALSE(env, condition, status) \

do { \

if (!(condition)) { \

return napi_set_last_error((env), (status)); \

} \

} while (0)

#define CHECK_ENV(env) \

do { \

if ((env) == nullptr) { \

return napi_invalid_arg; \

} \

} while (0)

#define CHECK_ARG(env, arg) \

RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)

#define CHECK_MAYBE_EMPTY(env, maybe, status) \

RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status))

#define CHECK_MAYBE_NOTHING(env, maybe, status) \

RETURN_STATUS_IF_FALSE((env), !((maybe).IsNothing()), (status))

#define NAPI_PREAMBLE(env) \

CHECK_ENV((env)); \

RETURN_STATUS_IF_FALSE((env), (env)->last_exception.IsEmpty(), \

napi_pending_exception); \

napi_clear_last_error((env)); \

v8impl::TryCatch try_catch((env))

#define CHECK_TO_TYPE(env, type, context, result, src, status) \

do { \

CHECK_ARG((env), (src)); \

auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \

CHECK_MAYBE_EMPTY((env), maybe, (status)); \

(result) = maybe.ToLocalChecked(); \

} while (0)

#define CHECK_TO_FUNCTION(env, result, src) \

do { \

CHECK_ARG((env), (src)); \

v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src)); \

RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \

(result) = v8value.As<v8::Function>(); \

} while (0)

#define CHECK_TO_OBJECT(env, context, result, src) \

CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)

#define CHECK_TO_STRING(env, context, result, src) \

CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected)

#define CHECK_TO_NUMBER(env, context, result, src) \

CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected)

#define CHECK_TO_BOOL(env, context, result, src) \

CHECK_TO_TYPE((env), Boolean, (context), (result), (src), \

napi_boolean_expected)

#define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len) \

do { \

static_assert(static_cast<int>(NAPI_AUTO_LENGTH) == -1, \

"Casting NAPI_AUTO_LENGTH to int must result in -1"); \

RETURN_STATUS_IF_FALSE((env), \

(len == NAPI_AUTO_LENGTH) || len <= INT_MAX, \

napi_invalid_arg); \

auto str_maybe = v8::String::NewFromUtf8( \

(env)->isolate, (str), v8::NewStringType::kInternalized, \

static_cast<int>(len)); \

CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure); \

(result) = str_maybe.ToLocalChecked(); \

} while (0)

#define CHECK_NEW_FROM_UTF8(env, result, str) \

CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), NAPI_AUTO_LENGTH)

#define GET_RETURN_STATUS(env) \

(!try_catch.HasCaught() ? napi_ok \

: napi_set_last_error((env), napi_pending_exception))

#define THROW_RANGE_ERROR_IF_FALSE(env, condition, error, message) \

do { \

if (!(condition)) { \

napi_throw_range_error((env), (error), (message)); \

return napi_set_last_error((env), napi_generic_failure); \

} \

} while (0)

#define CREATE_TYPED_ARRAY( \

env, type, size_of_element, buffer, byte_offset, length, out) \

do { \

if ((size_of_element) > 1) { \

THROW_RANGE_ERROR_IF_FALSE( \

(env), (byte_offset) % (size_of_element) == 0, \

"ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", \

"start offset of "#type" should be a multiple of "#size_of_element); \

} \

THROW_RANGE_ERROR_IF_FALSE((env), (length) * (size_of_element) + \

(byte_offset) <= buffer->ByteLength(), \

"ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", \

"Invalid typed array length"); \

(out) = v8::type::New((buffer), (byte_offset), (length)); \

} while (0)

#define NAPI_CALL_INTO_MODULE(env, call, handle_exception) \

do { \

int open_handle_scopes = (env)->open_handle_scopes; \

int open_callback_scopes = (env)->open_callback_scopes; \

napi_clear_last_error((env)); \

call; \

CHECK_EQ((env)->open_handle_scopes, open_handle_scopes); \

CHECK_EQ((env)->open_callback_scopes, open_callback_scopes); \

if (!(env)->last_exception.IsEmpty()) { \

handle_exception( \

v8::Local<v8::Value>::New((env)->isolate, (env)->last_exception)); \

(env)->last_exception.Reset(); \

} \

} while (0)

#define NAPI_CALL_INTO_MODULE_THROW(env, call) \

NAPI_CALL_INTO_MODULE((env), call, (env)->isolate->ThrowException)

namespace {

namespace v8impl {

static inline v8::PropertyAttribute V8PropertyAttributesFromDescriptor(

}

class HandleScopeWrapper {

};

class EscapableHandleScopeWrapper {

};

napi_handle_scope JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) {

return reinterpret_cast<napi_handle_scope>(s);

}

HandleScopeWrapper* V8HandleScopeFromJsHandleScope(napi_handle_scope s) {

return reinterpret_cast<HandleScopeWrapper*>(s);

}

napi_escapable_handle_scope JsEscapableHandleScopeFromV8EscapableHandleScope(

EscapableHandleScopeWrapper* s) {

return reinterpret_cast<napi_escapable_handle_scope>(s);

}

EscapableHandleScopeWrapper*

V8EscapableHandleScopeFromJsEscapableHandleScope(

napi_escapable_handle_scope s) {

return reinterpret_cast<EscapableHandleScopeWrapper*>(s);

}

napi_callback_scope JsCallbackScopeFromV8CallbackScope(

node::CallbackScope* s) {

return reinterpret_cast<napi_callback_scope>(s);

}

node::CallbackScope* V8CallbackScopeFromJsCallbackScope(

napi_callback_scope s) {

return reinterpret_cast<node::CallbackScope*>(s);

}

static_assert(sizeof(v8::Local<v8::Value>) == sizeof(napi_value),

"Cannot convert between v8::Local<v8::Value> and napi_value");

napi_deferred JsDeferredFromNodePersistent(node::Persistent<v8::Value>* local) {

return reinterpret_cast<napi_deferred>(local);

}

node::Persistent<v8::Value>* NodePersistentFromJsDeferred(napi_deferred local) {

return reinterpret_cast<node::Persistent<v8::Value>*>(local);

}

napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {

return reinterpret_cast<napi_value>(*local);

}

v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {

}

static inline void trigger_fatal_exception(

}

static inline napi_status V8NameFromPropertyDescriptor(napi_env env,

}

class Finalizer {

};

class Reference : private Finalizer {

};

class TryCatch : public v8::TryCatch {

};

struct CallbackBundle {

};

class CallbackWrapper {

};

template <typename Info, napi_callback CallbackBundle::*FunctionField>

class CallbackWrapperBase : public CallbackWrapper {

};

class FunctionCallbackWrapper

};

class GetterCallbackWrapper

};

class SetterCallbackWrapper

};

v8::Local<v8::Value> CreateFunctionCallbackData(napi_env env,

}

v8::Local<v8::Value> CreateAccessorCallbackData(napi_env env,

}

napi_env GetEnv(v8::Local<v8::Context> context) {

}

enum UnwrapAction {

KeepWrap,

RemoveWrap

};

napi_status Unwrap(napi_env env,

}

napi_status ConcludeDeferred(napi_env env,

}

class ThreadSafeFunction : public node::AsyncResource {