isolate_ = tns::Runtime::GetCurrentRuntime()->GetIsolate();

// V8Runtime::V8Runtime(

// std::unique_ptr<V8RuntimeConfig> config,

// std::shared_ptr<facebook::react::MessageQueueThread> jsQueue)

// : config_(std::move(config)) {

// {

// const std::lock_guard<std::mutex> lock(s_platform_mutex);

// if (!s_platform) {

// s_platform = v8::platform::NewDefaultPlatform();

// v8::V8::InitializeICU();

// v8::V8::InitializePlatform(s_platform.get());

// #if TARGET_OS_IOS

// v8::V8::SetFlagsFromString("--nolazy --nofreeze_flags_after_init");

// #else

// v8::V8::SetFlagsFromString("--nolazy");

// #endif

// v8::V8::Initialize();

// }

// }

// if (config_->snapshotBlob) {

// snapshotBlob_ = std::make_unique<v8::StartupData>();

// snapshotBlob_->data = config_->snapshotBlob->c_str();

// snapshotBlob_->raw_size =

// static_cast<int>(config_->snapshotBlob->size());

// createParams.snapshot_blob = snapshotBlob_.get();

// }

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

context_.Reset(isolate_, isolate_->GetCurrentContext());

v8::Context::Scope scopedContext(context_.Get(isolate_));

arrayBufferAllocator_.reset(

v8::ArrayBuffer::Allocator::NewDefaultAllocator());

// jsQueue_ = jsQueue;

// if (config_->enableInspector) {

// inspectorClient_ = std::make_shared<InspectorClient>(

// jsQueue_,

// context_.Get(isolate_),

// config_->appName,

// config_->deviceName);

// inspectorClient_->ConnectToReactFrontend();

// }

// v8::Locker locker(isolate_);

// v8::Isolate::Scope scopedIsolate(isolate_);

// v8::HandleScope scopedHandle(isolate_);

// v8::Context::Scope scopedContext(context_.Get(isolate_));

// while (v8::platform::PumpMessageLoop(

// s_platform.get(), isolate_,

// v8::platform::MessageLoopBehavior::kDoNotWait)) {

// continue;

// }

v8::TryCatch* tryCatch) const {

v8::HandleScope scopedHandle(isolate);

std::string exception =

JSIV8ValueConverter::ToSTLString(isolate, tryCatch->Exception());

v8::Local<v8::Message> message = tryCatch->Message();

if (message.IsEmpty()) {

// V8 didn't provide any extra information about this error; just

// print the exception.

throw jsi::JSError(const_cast<V8Runtime&>(*this), exception);

return;

} else {

std::ostringstream ss;

v8::Local<v8::Context> context(isolate->GetCurrentContext());

// Print (filename):(line number): (message).

ss << JSIV8ValueConverter::ToSTLString(

isolate, message->GetScriptOrigin().ResourceName())

<< ":" << message->GetLineNumber(context).FromJust() << ": " << exception

<< std::endl;

// Print line of source code.

ss << JSIV8ValueConverter::ToSTLString(

isolate, message->GetSourceLine(context).ToLocalChecked())

<< std::endl;

// Print wavy underline (GetUnderline is deprecated).

int start = message->GetStartColumn(context).FromJust();

for (int i = 0; i < start; i++) {

ss << " ";

}

int end = message->GetEndColumn(context).FromJust();

for (int i = start; i < end; i++) {

ss << "^";

}

ss << std::endl;

v8::Local<v8::Value> stackTraceString;

if (tryCatch->StackTrace(context).ToLocal(&stackTraceString) &&

stackTraceString->IsString() &&

v8::Local<v8::String>::Cast(stackTraceString)->Length() > 0) {

v8::String::Utf8Value stackTrace(isolate, stackTraceString);

std::string stlStack = JSIV8ValueConverter::ToSTLString(stackTrace);

// Reverted: do not remap stack here

ss << stlStack << std::endl;

}

throw jsi::JSError(const_cast<V8Runtime&>(*this), ss.str());

return;

}

v8::Local<v8::Object> object) const {

if (object->InternalFieldCount() != 2) {

return V8Runtime::InternalFieldType::kInvalid;

}

v8::Local<v8::Value> typeValue = object->GetInternalField(0);

assert(typeValue->IsUint32());

return static_cast<V8Runtime::InternalFieldType>(

v8::Local<v8::Uint32>::Cast(typeValue)->Value());

const std::shared_ptr<const jsi::Buffer>& buffer,

const std::string& sourceURL) {

return {};

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

while (v8::platform::PumpMessageLoop(

s_platform.get(), isolate_,

v8::platform::MessageLoopBehavior::kDoNotWait)) {

continue;

}

isolate_->PerformMicrotaskCheckpoint();

return true;

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

return make<jsi::Object>(

new V8PointerValue(isolate_, context_.Get(isolate_)->Global()));

std::ostringstream ss;

ss << "<V8Runtime@" << this << ">";

return ss.str();

size_t length) {

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

V8PointerValue* value =

V8PointerValue::createFromOneByte(isolate_, str, length);

if (!value) {

throw jsi::JSError(*this, "createFromOneByte() - string creation failed.");

}

return make<jsi::PropNameID>(value);

size_t length) {

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

V8PointerValue* value =

V8PointerValue::createFromUtf8(isolate_, utf8, length);

if (!value) {

throw jsi::JSError(*this, "createFromUtf8() - string creation failed.");

}

return make<jsi::PropNameID>(value);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(str));

assert(v8PointerValue->Get(isolate_)->IsString());

v8::String::Utf8Value utf8(isolate_, v8PointerValue->Get(isolate_));

return createPropNameIDFromUtf8(reinterpret_cast<const uint8_t*>(*utf8),

utf8.length());

const facebook::jsi::Symbol& sym) {

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

assert(static_cast<const V8PointerValue*>(getPointerValue(sym))

->Get(isolate_)

->IsSymbol());

return make<jsi::PropNameID>(const_cast<PointerValue*>(getPointerValue(sym)));

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(sym));

v8::String::Utf8Value utf8(isolate_, v8PointerValue->Get(isolate_));

return JSIV8ValueConverter::ToSTLString(utf8);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValueA =

static_cast<const V8PointerValue*>(getPointerValue(a));

const V8PointerValue* v8PointerValueB =

static_cast<const V8PointerValue*>(getPointerValue(b));

v8::Local<v8::String> v8StringA =

v8::Local<v8::String>::Cast(v8PointerValueA->Get(isolate_));

v8::Local<v8::String> v8StringB =

v8::Local<v8::String>::Cast(v8PointerValueB->Get(isolate_));

return v8StringA->StringEquals(v8StringB);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::BigInt> v8BigInt = v8::BigInt::New(isolate_, value);

return make<jsi::BigInt>(new V8PointerValue(isolate_, v8BigInt));

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::BigInt> v8BigInt = v8::BigInt::NewFromUnsigned(isolate_, value);

return make<jsi::BigInt>(new V8PointerValue(isolate_, v8BigInt));

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(value));

assert(v8PointerValue->Get(isolate_)->IsBigInt());

v8::Local<v8::BigInt> v8BigInt =

v8::Local<v8::BigInt>::Cast(v8PointerValue->Get(isolate_));

bool lossless = false;

v8BigInt->Int64Value(&lossless);

return lossless == true;

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(value));

assert(v8PointerValue->Get(isolate_)->IsBigInt());

v8::Local<v8::BigInt> v8BigInt =

v8::Local<v8::BigInt>::Cast(v8PointerValue->Get(isolate_));

bool lossless = false;

v8BigInt->Uint64Value(&lossless);

return lossless == true;

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(value));

assert(v8PointerValue->Get(isolate_)->IsBigInt());

v8::Local<v8::BigInt> v8BigInt =

v8::Local<v8::BigInt>::Cast(v8PointerValue->Get(isolate_));

return v8BigInt->Uint64Value();

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(value));

assert(v8PointerValue->Get(isolate_)->IsBigInt());

v8::Local<v8::BigInt> v8Value =

v8::Local<v8::BigInt>::Cast(v8PointerValue->Get(isolate_));

// V8 does not expose `toString(radix)` in its API, so we have to use

// `BigInt.prototype.toString.call(value, radix)` instead.

v8::Local<v8::Object> global = context_.Get(isolate_)->Global();

v8::Local<v8::Object> bigintClass = v8::Local<v8::Object>::Cast(

global

->Get(isolate_->GetCurrentContext(),

v8::String::NewFromUtf8Literal(isolate_, "BigInt"))

.ToLocalChecked());

v8::Local<v8::Object> bigintProto = v8::Local<v8::Object>::Cast(

bigintClass

->Get(isolate_->GetCurrentContext(),

v8::String::NewFromUtf8Literal(isolate_, "prototype"))

.ToLocalChecked());

v8::Local<v8::Function> bigintToStringFunction =

v8::Local<v8::Function>::Cast(

bigintProto

->Get(isolate_->GetCurrentContext(),

v8::String::NewFromUtf8Literal(isolate_, "toString"))

.ToLocalChecked());

v8::Local<v8::Value> args[] = {v8::Integer::New(isolate_, radix)};

v8::Local<v8::Value> result =

bigintToStringFunction

->Call(isolate_->GetCurrentContext(), v8Value, 1, args)

.ToLocalChecked();

assert(result->IsString());

return V8Runtime::make<jsi::String>(new V8PointerValue(isolate_, result));

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

V8PointerValue* value =

V8PointerValue::createFromOneByte(isolate_, str, length);

if (!value) {

throw jsi::JSError(*this, "createFromOneByte() - string creation failed.");

}

return make<jsi::String>(value);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

V8PointerValue* value = V8PointerValue::createFromUtf8(isolate_, str, length);

if (!value) {

throw jsi::JSError(*this, "createFromUtf8() - string creation failed.");

}

return make<jsi::String>(value);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

const V8PointerValue* v8PointerValue =

static_cast<const V8PointerValue*>(getPointerValue(str));

assert(v8PointerValue->Get(isolate_)->IsString());

v8::String::Utf8Value utf8(isolate_, v8PointerValue->Get(isolate_));

return JSIV8ValueConverter::ToSTLString(utf8);

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::Object> object = v8::Object::New(isolate_);

return make<jsi::Object>(new V8PointerValue(isolate_, object));

std::shared_ptr<jsi::HostObject> hostObject) {

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

HostObjectProxy* hostObjectProxy =

new HostObjectProxy(*this, isolate_, hostObject);

v8::Local<v8::Object> v8Object;

v8::Local<v8::ObjectTemplate> hostObjectTemplate =

v8::ObjectTemplate::New(isolate_);

hostObjectTemplate->SetHandler(v8::NamedPropertyHandlerConfiguration(

HostObjectProxy::Getter, HostObjectProxy::Setter, nullptr, nullptr,

HostObjectProxy::Enumerator));

hostObjectTemplate->SetInternalFieldCount(2);

if (!hostObjectTemplate->NewInstance(isolate_->GetCurrentContext())

.ToLocal(&v8Object)) {

delete hostObjectProxy;

throw jsi::JSError(*this, "Unable to create HostObject");

}

v8::Local<v8::External> wrappedHostObjectProxy =

v8::External::New(isolate_, hostObjectProxy);

v8Object->SetInternalField(0, v8::Integer::NewFromUnsigned(

isolate_, InternalFieldType::kHostObject));

v8Object->SetInternalField(1, wrappedHostObjectProxy);

hostObjectProxy->BindFinalizer(v8Object);

return make<jsi::Object>(new V8PointerValue(isolate_, v8Object));

const jsi::Object& object) {

assert(isHostObject(object));

// We are guarenteed at this point to have isHostObject(obj) == true

// so the internal data should be HostObjectMetadata

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::Object> v8Object =

JSIV8ValueConverter::ToV8Object(*this, object);

v8::Local<v8::External> internalField =

v8::Local<v8::External>::Cast(v8Object->GetInternalField(1));

HostObjectProxy* hostObjectProxy =

reinterpret_cast<HostObjectProxy*>(internalField->Value());

assert(hostObjectProxy);

return hostObjectProxy->GetHostObject();

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::Object> v8Object =

JSIV8ValueConverter::ToV8Object(*this, object);

return GetInternalFieldType(v8Object) == InternalFieldType::kNativeState;

const jsi::Object& object) {

if (isHostObject(object)) {

throw jsi::JSINativeException("native state unsupported on HostObject");

}

assert(hasNativeState(object));

// We are guarenteed at this point to have hasNativeState(obj) == true

// so the internal data should be a NativeState

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::Object> v8Object =

JSIV8ValueConverter::ToV8Object(*this, object);

auto* nativeStatePtr = reinterpret_cast<std::shared_ptr<jsi::NativeState>*>(

v8Object->GetAlignedPointerFromInternalField(1));

return std::shared_ptr(*nativeStatePtr);

std::shared_ptr<jsi::NativeState> state) {

if (isHostObject(object)) {

throw jsi::JSINativeException("native state unsupported on HostObject");

}

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::Local<v8::Object> v8ObjectOriginal =

JSIV8ValueConverter::ToV8Object(*this, object);

v8::Local<v8::ObjectTemplate> objectTemplate =

v8::ObjectTemplate::New(isolate_);

objectTemplate->SetInternalFieldCount(2);

v8::Local<v8::Object> v8Object;

if (!objectTemplate->NewInstance(isolate_->GetCurrentContext())

.ToLocal(&v8Object)) {

throw jsi::JSError(*this, "Unable to create new Object for setNativeState");

}

V8PointerValue* v8PointerValue = static_cast<V8PointerValue*>(

const_cast<Runtime::PointerValue*>(getPointerValue(object)));

v8PointerValue->Reset(isolate_, v8Object);

v8Object->SetInternalField(0, v8::Integer::NewFromUnsigned(

isolate_, InternalFieldType::kNativeState));

// Allocate a shared_ptr on the C++ heap and use it as context of NativeState.

auto* nativeStatePtr =

new std::shared_ptr<jsi::NativeState>(std::move(state));

v8Object->SetAlignedPointerInInternalField(

1, reinterpret_cast<void*>(nativeStatePtr));

// Clone properties to the new object created from object template with

// two internal fields.

v8::Local<v8::Object> global = context_.Get(isolate_)->Global();

v8::Local<v8::Object> objectClass = v8::Local<v8::Object>::Cast(

global

->Get(isolate_->GetCurrentContext(),

v8::String::NewFromUtf8Literal(isolate_, "Object"))

.ToLocalChecked());

v8::Local<v8::Function> objectAssignFunction = v8::Local<v8::Function>::Cast(

objectClass

->Get(isolate_->GetCurrentContext(),

v8::String::NewFromUtf8Literal(isolate_, "assign"))

.ToLocalChecked());

v8::Local<v8::Value> args[] = {v8Object, v8ObjectOriginal};

objectAssignFunction

->Call(isolate_->GetCurrentContext(), v8::Undefined(isolate_), 2, args)

.ToLocalChecked();

// Bind a global handle with weak callback to cleanup the shared_ptr

// on the C++ heap.

v8::Global<v8::Object> weakV8Object(isolate_, v8Object);

weakV8Object.SetWeak(

&weakV8Object,

[](const v8::WeakCallbackInfo<v8::Global<v8::Object>>& data) {

v8::Global<v8::Object>* weakV8ObjectPtr = data.GetParameter();

weakV8ObjectPtr->Reset();

delete reinterpret_cast<std::shared_ptr<jsi::NativeState>*>(

data.GetInternalField(1));

},

v8::WeakCallbackType::kInternalFields);

const jsi::PropNameID& name) {

v8::Locker locker(isolate_);

v8::Isolate::Scope scopedIsolate(isolate_);

v8::HandleScope scopedHandle(isolate_);

v8::Context::Scope scopedContext(context_.Get(isolate_));

v8::TryCatch tryCatch(isolate_);

v8::Local<v8::Object> v8Object =

JSIV8ValueConverter::ToV8Object(*this, object);

v8::MaybeLocal<v8::Value> result =

v8Object->Get(isolate_->GetCurrentContext(),

JSIV8ValueConverter::ToV8String(*this, name));

if (tryCatch.HasCaught()) {

ReportException(isolate_, &tryCatch);

}

if (result.IsEmpty()) {

return jsi::Value::undefined();

}

return JSIV8ValueConverter::ToJSIValue(isolate_, result.ToLocalChecked());