#include <algorithm>

#include <climits> // INT_MAX

#include <cmath>

#ifndef NAPI_EXPERIMENTAL

#define NAPI_EXPERIMENTAL

#endif

#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 : private RefTracker {

};

class ExternalOneByteStringResource final

};

class ExternalStringResource final : 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 FunctionCallbackWrapper {

};

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::ResetEnv() {

env_ = nullptr;

}

void Finalizer::ResetFinalizer() {

}

void Finalizer::CallFinalizer() {

}

TrackedFinalizer::TrackedFinalizer(napi_env env,

finalizer_(env, finalize_callback, finalize_data, finalize_hint) {}

TrackedFinalizer* TrackedFinalizer::New(napi_env env,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

TrackedFinalizer* finalizer = new TrackedFinalizer(

env, finalize_callback, finalize_data, finalize_hint);

finalizer->Link(&env->finalizing_reflist);

return finalizer;

}

TrackedFinalizer::~TrackedFinalizer() {

// Remove from the env's tracked list.

Unlink();

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

finalizer_.env()->DequeueFinalizer(this);

}

void TrackedFinalizer::Finalize() {

}

Reference::Reference(napi_env env,

}

Reference::~Reference() {

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

persistent_.Reset();

// Remove from the env's tracked list.

Unlink();

}

Reference* Reference::New(napi_env env,

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

uint32_t initial_refcount,

ReferenceOwnership ownership) {

Reference* reference = new Reference(env, value, initial_refcount, ownership);

reference->Link(&env->reflist);

return reference;

}

uint32_t Reference::Ref() {

}

uint32_t Reference::Unref() {

}

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

}

void Reference::Finalize() {

}

void Reference::InvokeFinalizerFromGC() {

Finalize();

}

void Reference::SetWeak() {

}

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

}

ReferenceWithData* ReferenceWithData::New(napi_env env,

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

uint32_t initial_refcount,

ReferenceOwnership ownership,

void* data) {

ReferenceWithData* reference =

new ReferenceWithData(env, value, initial_refcount, ownership, data);

reference->Link(&env->reflist);

return reference;

}

ReferenceWithData::ReferenceWithData(napi_env env,

: Reference(env, value, initial_refcount, ownership), data_(data) {}

ReferenceWithFinalizer* ReferenceWithFinalizer::New(

napi_env env,

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

uint32_t initial_refcount,

ReferenceOwnership ownership,

napi_finalize finalize_callback,

void* finalize_data,

void* finalize_hint) {

ReferenceWithFinalizer* reference =

new ReferenceWithFinalizer(env,

value,

initial_refcount,

ownership,

finalize_callback,

finalize_data,

finalize_hint);

reference->Link(&env->finalizing_reflist);

return reference;

}

ReferenceWithFinalizer::ReferenceWithFinalizer(napi_env env,

finalizer_(env, finalize_callback, finalize_data, finalize_hint) {}

ReferenceWithFinalizer::~ReferenceWithFinalizer() {

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

finalizer_.env()->DequeueFinalizer(this);

}

void ReferenceWithFinalizer::CallUserFinalizer() {

finalizer_.CallFinalizer();

}

void ReferenceWithFinalizer::InvokeFinalizerFromGC() {

finalizer_.env()->InvokeFinalizerFromGC(this);

}

class ExternalWrapper {

};

} // 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,