#include <algorithm>

#include <climits> // INT_MAX

#include <cmath>

#define NAPI_EXPERIMENTAL

#include "env-inl.h"

#include "js_native_api.h"

#include "js_native_api_v8.h"

#include "util-inl.h"

#define CHECK_MAYBE_NOTHING(env, maybe, status) \

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

#define CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe, status) \

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

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

CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_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); \

RETURN_STATUS_IF_FALSE((env), (str) != nullptr, 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 CHECK_NEW_STRING_ARGS(env, str, length, result) \

do { \

CHECK_ENV_NOT_IN_GC((env)); \

if ((length) > 0) CHECK_ARG((env), (str)); \

CHECK_ARG((env), (result)); \

RETURN_STATUS_IF_FALSE( \

(env), \

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

napi_invalid_arg); \

} 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)

void napi_env__::InvokeFinalizerFromGC(v8impl::RefTracker* finalizer) {

}

namespace v8impl {

namespace {

template <typename CCharType, typename StringMaker>

napi_status NewString(napi_env env,

}

template <typename CharType, typename CreateAPI, typename StringMaker>

napi_status NewExternalString(napi_env env,

}

class TrackedStringResource : public Finalizer, RefTracker {

};

class ExternalOneByteStringResource

};

class ExternalStringResource : public v8::String::ExternalStringResource,

};

inline napi_status V8NameFromPropertyDescriptor(

}

inline v8::PropertyAttribute V8PropertyAttributesFromDescriptor(

}

inline napi_deferred JsDeferredFromNodePersistent(

v8impl::Persistent<v8::Value>* local) {

return reinterpret_cast<napi_deferred>(local);

}

inline v8impl::Persistent<v8::Value>* NodePersistentFromJsDeferred(

napi_deferred local) {

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

}

class HandleScopeWrapper {

};

class EscapableHandleScopeWrapper {

};

inline napi_handle_scope JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) {

return reinterpret_cast<napi_handle_scope>(s);

}

inline HandleScopeWrapper* V8HandleScopeFromJsHandleScope(napi_handle_scope s) {

return reinterpret_cast<HandleScopeWrapper*>(s);

}

inline napi_escapable_handle_scope

JsEscapableHandleScopeFromV8EscapableHandleScope(

EscapableHandleScopeWrapper* s) {

return reinterpret_cast<napi_escapable_handle_scope>(s);

}

inline EscapableHandleScopeWrapper*

V8EscapableHandleScopeFromJsEscapableHandleScope(

napi_escapable_handle_scope s) {

return reinterpret_cast<EscapableHandleScopeWrapper*>(s);

}

inline napi_status ConcludeDeferred(napi_env env,

}

enum UnwrapAction { KeepWrap, RemoveWrap };

inline napi_status Unwrap(napi_env env,

}

class CallbackBundle {

};

class CallbackWrapper {

};

class CallbackWrapperBase : public CallbackWrapper {

};

class FunctionCallbackWrapper : public CallbackWrapperBase {

};

inline napi_status Wrap(napi_env env,

}

inline bool CanBeHeldWeakly(v8::Local<v8::Value> value) {

return value->IsObject() || value->IsSymbol();

}

} // end of anonymous namespace

void Finalizer::ResetFinalizer() {

}

TrackedFinalizer::TrackedFinalizer(napi_env env,

}

TrackedFinalizer* TrackedFinalizer::New(napi_env env,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

return new TrackedFinalizer(

env, finalize_callback, finalize_data, finalize_hint);

}

TrackedFinalizer::~TrackedFinalizer() {

// Remove from the env's tracked list.

Unlink();

// Try to remove the finalizer from the scheduled second pass callback.

env_->DequeueFinalizer(this);

}

void TrackedFinalizer::Finalize() {

FinalizeCore(/*deleteMe:*/ true);

}

void TrackedFinalizer::FinalizeCore(bool deleteMe) {

}

RefBase::RefBase(napi_env env,

ownership_(ownership) {}

RefBase* RefBase::New(napi_env env,

uint32_t initial_refcount,

Ownership ownership,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

return new RefBase(env,

initial_refcount,

ownership,

finalize_callback,

finalize_data,

finalize_hint);

}

void* RefBase::Data() {

return finalize_data_;

}

uint32_t RefBase::Ref() {

return ++refcount_;

}

uint32_t RefBase::Unref() {

}

uint32_t RefBase::RefCount() {

return refcount_;

}

void RefBase::Finalize() {

}

template <typename... Args>

Reference::Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args)

}

Reference::~Reference() {

// Reset the handle. And no weak callback will be invoked.

persistent_.Reset();

}

Reference* Reference::New(napi_env env,

v8::Local<v8::Value> value,

uint32_t initial_refcount,

Ownership ownership,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

return new Reference(env,

value,

initial_refcount,

ownership,

finalize_callback,

finalize_data,

finalize_hint);

}

uint32_t Reference::Ref() {

}

uint32_t Reference::Unref() {

}

v8::Local<v8::Value> Reference::Get() {

}

void Reference::Finalize() {

}

void Reference::SetWeak() {

}

void Reference::WeakCallback(const v8::WeakCallbackInfo<Reference>& data) {

}

} // end of namespace v8impl

static const char* error_messages[] = {

nullptr,

"Invalid argument",

"An object was expected",

"A string was expected",

"A string or symbol was expected",

"A function was expected",

"A number was expected",

"A boolean was expected",

"An array was expected",

"Unknown failure",

"An exception is pending",

"The async work item was cancelled",

"napi_escape_handle already called on scope",

"Invalid handle scope usage",

"Invalid callback scope usage",

"Thread-safe function queue is full",

"Thread-safe function handle is closing",

"A bigint was expected",

"A date was expected",

"An arraybuffer was expected",

"A detachable arraybuffer was expected",

"Main thread would deadlock",

"External buffers are not allowed",

"Cannot run JavaScript",

};

napi_status NAPI_CDECL napi_get_last_error_info(

}

napi_status NAPI_CDECL napi_create_function(napi_env env,

}

napi_status NAPI_CDECL

napi_define_class(napi_env env,