Local<v8::String> message) {

Isolate* isolate = context->GetIsolate();

// Local<Value> argv[] = {message,

// FIXED_ONE_BYTE_STRING(isolate, "DataCloneError")};

Local<Value> exception;

Local<v8::Function> domexception_ctor;

NativeScriptException except(isolate, tns::ToString(isolate, message),

"DataCloneError");

except.ReThrowToV8(isolate);

public:

SerializerDelegate(Isolate* isolate, Local<Context> context, Message* m)

: isolate_(isolate), context_(context), msg_(m) {}

void ThrowDataCloneError(Local<v8::String> message) override {

ThrowDataCloneException(context_, message);

}

Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {

return Just(true);

// if (BaseObject::IsBaseObject(object)) {

// return WriteHostObject(

// BaseObjectPtr<BaseObject> { Unwrap<BaseObject>(object) });

// }

//

// // Convert process.env to a regular object.

// auto env_proxy_ctor_template = env_->env_proxy_ctor_template();

// if (!env_proxy_ctor_template.IsEmpty() &&

// env_proxy_ctor_template->HasInstance(object)) {

// HandleScope scope(isolate);

// // TODO(bnoordhuis) Prototype-less object in case process.env

// contains

// // a "__proto__" key? process.env has a prototype with concomitant

// // methods like toString(). It's probably confusing if that gets

// lost

// // in transmission.

// Local<Object> normal_object = Object::New(isolate);

// env_->env_vars()->AssignToObject(isolate, env_->context(),

// normal_object); serializer->WriteUint32(kNormalObject); // Instead

// of a BaseObject. return serializer->WriteValue(env_->context(),

// normal_object);

// }

//

// ThrowDataCloneError(env_->clone_unsupported_type_str());

// return Nothing<bool>();

}

Maybe<uint32_t> GetSharedArrayBufferId(

Isolate* isolate, Local<SharedArrayBuffer> shared_array_buffer) override {

uint32_t i;

for (i = 0; i < seen_shared_array_buffers_.size(); ++i) {

if (PersistentToLocal::Strong(seen_shared_array_buffers_[i]) ==

shared_array_buffer) {

return Just(i);

}

}

seen_shared_array_buffers_.emplace_back(

Global<SharedArrayBuffer>{isolate, shared_array_buffer});

msg_->AddSharedArrayBuffer(shared_array_buffer->GetBackingStore());

return Just(i);

}

// Maybe<uint32_t> GetWasmModuleTransferId(

// Isolate* isolate, Local<WasmModuleObject> module) override {

// return Just(msg_->AddWASMModule(module->GetCompiledModule()));

// }

// bool AdoptSharedValueConveyor(Isolate* isolate,

// SharedValueConveyor&& conveyor) override {

// msg_->AdoptSharedValueConveyor(std::move(conveyor));

// return true;

// }

// Maybe<bool> Finish(Local<Context> context) {

// for (uint32_t i = 0; i < host_objects_.size(); i++) {

// BaseObjectPtr<BaseObject> host_object = std::move(host_objects_[i]);

// std::unique_ptr<TransferData> data;

// if (i < first_cloned_object_index_)

// data = host_object->TransferForMessaging();

// if (!data)

// data = host_object->CloneForMessaging();

// if (!data) return Nothing<bool>();

// if (data->FinalizeTransferWrite(context, serializer).IsNothing())

// return Nothing<bool>();

// msg_->AddTransferable(std::move(data));

// }

// return Just(true);

// }

// inline void AddHostObject(BaseObjectPtr<BaseObject> host_object) {

// // Make sure we have not started serializing the value itself yet.

// CHECK_EQ(first_cloned_object_index_, SIZE_MAX);

// host_objects_.emplace_back(std::move(host_object));

// }

//

// // Some objects in the transfer list may register sub-objects that can be

// // transferred. This could e.g. be a public JS wrapper object, such as a

// // FileHandle, that is registering its C++ handle for transfer.

// inline Maybe<bool> AddNestedHostObjects() {

// for (size_t i = 0; i < host_objects_.size(); i++) {

// std::vector<BaseObjectPtr<BaseObject>> nested_transferables;

// if

// (!host_objects_[i]->NestedTransferables().To(&nested_transferables))

// return Nothing<bool>();

// for (auto& nested_transferable : nested_transferables) {

// if (std::find(host_objects_.begin(),

// host_objects_.end(),

// nested_transferable) == host_objects_.end()) {

// AddHostObject(nested_transferable);

// }

// }

// }

// return Just(true);

// }

ValueSerializer* serializer = nullptr;

private:

// Maybe<bool> WriteHostObject(BaseObjectPtr<BaseObject> host_object) {

// BaseObject::TransferMode mode = host_object->GetTransferMode();

// if (mode == BaseObject::TransferMode::kUntransferable) {

// ThrowDataCloneError(env_->clone_unsupported_type_str());

// return Nothing<bool>();

// }

//

// for (uint32_t i = 0; i < host_objects_.size(); i++) {

// if (host_objects_[i] == host_object) {

// serializer->WriteUint32(i);

// return Just(true);

// }

// }

//

// if (mode == BaseObject::TransferMode::kTransferable) {

// THROW_ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST(env_);

// return Nothing<bool>();

// }

//

// CHECK_EQ(mode, BaseObject::TransferMode::kCloneable);

// uint32_t index = host_objects_.size();

// if (first_cloned_object_index_ == SIZE_MAX)

// first_cloned_object_index_ = index;

// serializer->WriteUint32(index);

// host_objects_.push_back(host_object);

// return Just(true);

// }

__unused Isolate* isolate_;

__unused Local<Context> context_;

Message* msg_;

std::vector<Global<SharedArrayBuffer>> seen_shared_array_buffers_;

// std::vector<BaseObjectPtr<BaseObject>> host_objects_;

__unused size_t first_cloned_object_index_ = SIZE_MAX;

friend class tns::worker::Message;

public:

DeserializerDelegate(

Message* m, Isolate* isolate,

// const std::vector<BaseObjectPtr<BaseObject>>& host_objects,

const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers

// const std::vector<CompiledWasmModule>& wasm_modules,

// const std::optional<SharedValueConveyor>& shared_value_conveyor

)

: // host_objects_(host_objects),

shared_array_buffers_(shared_array_buffers)

// wasm_modules_(wasm_modules),

// shared_value_conveyor_(shared_value_conveyor)

{}

MaybeLocal<Object> ReadHostObject(Isolate* isolate) override {

EscapableHandleScope scope(isolate);

Local<Object> object = Object::New(isolate);

return scope.Escape(object).As<Object>();

// // Identifying the index in the message's BaseObject array is

// sufficient. uint32_t id; if (!deserializer->ReadUint32(&id))

// return MaybeLocal<Object>();

// if (id != kNormalObject) {

// CHECK_LT(id, host_objects_.size());

// return host_objects_[id]->object(isolate);

// }

// EscapableHandleScope scope(isolate);

// Local<Context> context = isolate->GetCurrentContext();

// Local<Value> object;

// if (!deserializer->ReadValue(context).ToLocal(&object))

// return MaybeLocal<Object>();

// CHECK(object->IsObject());

// return scope.Escape(object.As<Object>());

}

MaybeLocal<SharedArrayBuffer> GetSharedArrayBufferFromId(

Isolate* isolate, uint32_t clone_id) override {

// CHECK_LT(clone_id, shared_array_buffers_.size());

return shared_array_buffers_[clone_id];

}

// MaybeLocal<WasmModuleObject> GetWasmModuleFromId(

// Isolate* isolate, uint32_t transfer_id) override {

//// CHECK_LT(transfer_id, wasm_modules_.size());

// return WasmModuleObject::FromCompiledModule(

// isolate, wasm_modules_[transfer_id]);

// }

// const SharedValueConveyor* GetSharedValueConveyor(Isolate* isolate)

// override {

//// CHECK(shared_value_conveyor_.has_value());

// return &shared_value_conveyor_.value();

// }

ValueDeserializer* deserializer = nullptr;

private:

// const std::vector<BaseObjectPtr<BaseObject>>& host_objects_;

const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers_;

// const std::vector<CompiledWasmModule>& wasm_modules_;

// const std::optional<SharedValueConveyor>& shared_value_conveyor_;

v8::Local<v8::Context> context,

v8::Local<v8::Value> input) {

HandleScope handle_scope(isolate);

v8::Context::Scope context_scope(context);

// Verify that we're not silently overwriting an existing message.

tns::Assert(main_message_buf_.is_empty());

SerializerDelegate delegate(isolate, context, this);

ValueSerializer serializer(isolate, &delegate);

delegate.serializer = &serializer;

std::vector<Local<ArrayBuffer>> array_buffers;

// for (uint32_t i = 0; i < transfer_list_v.length(); ++i) {

// Local<Value> entry = transfer_list_v[i];

// if (entry->IsObject()) {

// // See

// https://github.com/nodejs/node/pull/30339#issuecomment-552225353

// // for details.

// bool untransferable;

// if (!entry.As<Object>()->HasPrivate(

// context,

// env->untransferable_object_private_symbol())

// .To(&untransferable)) {

// return Nothing<bool>();

// }

// if (untransferable) {

// ThrowDataCloneException(context,

// env->transfer_unsupported_type_str()); return Nothing<bool>();

// }

// }

//

// // Currently, we support ArrayBuffers and BaseObjects for which

// // GetTransferMode() returns kTransferable.

// if (entry->IsArrayBuffer()) {

// Local<ArrayBuffer> ab = entry.As<ArrayBuffer>();

// // If we cannot render the ArrayBuffer unusable in this Isolate,

// // copying the buffer will have to do.

// // Note that we can currently transfer ArrayBuffers even if they

// were

// // not allocated by Node’s ArrayBufferAllocator in the first

// place,

// // because we pass the underlying v8::BackingStore around rather

// than

// // raw data *and* an Isolate with a non-default ArrayBuffer

// allocator

// // is always going to outlive any Workers it creates, and so will

// its

// // allocator along with it.

// if (!ab->IsDetachable() || ab->WasDetached()) {

// ThrowDataCloneException(context,

// env->transfer_unsupported_type_str()); return Nothing<bool>();

// }

// if (std::find(array_buffers.begin(), array_buffers.end(), ab) !=

// array_buffers.end()) {

// ThrowDataCloneException(

// context,

// FIXED_ONE_BYTE_STRING(

// env->isolate(),

// "Transfer list contains duplicate ArrayBuffer"));

// return Nothing<bool>();

// }

// // We simply use the array index in the `array_buffers` list as

// the

// // ID that we write into the serialized buffer.

// uint32_t id = array_buffers.size();

// array_buffers.push_back(ab);

// serializer.TransferArrayBuffer(id, ab);

// continue;

// } else if (entry->IsObject() &&

// BaseObject::IsBaseObject(entry.As<Object>())) {

// // Check if the source MessagePort is being transferred.

// if (!source_port.IsEmpty() && entry == source_port) {

// ThrowDataCloneException(

// context,

// FIXED_ONE_BYTE_STRING(env->isolate(),

// "Transfer list contains source

// port"));

// return Nothing<bool>();

// }

// BaseObjectPtr<BaseObject> host_object {

// Unwrap<BaseObject>(entry.As<Object>()) };

// if (env->message_port_constructor_template()->HasInstance(entry)

// &&

// (!host_object ||

// static_cast<MessagePort*>(host_object.get())->IsDetached()))

// {

// ThrowDataCloneException(

// context,

// FIXED_ONE_BYTE_STRING(

// env->isolate(),

// "MessagePort in transfer list is already detached"));

// return Nothing<bool>();

// }

// if (std::find(delegate.host_objects_.begin(),

// delegate.host_objects_.end(),

// host_object) != delegate.host_objects_.end()) {

// ThrowDataCloneException(

// context,

// String::Concat(env->isolate(),

// FIXED_ONE_BYTE_STRING(

// env->isolate(),

// "Transfer list contains duplicate "),

// entry.As<Object>()->GetConstructorName()));

// return Nothing<bool>();

// }

// if (host_object && host_object->GetTransferMode() ==

// BaseObject::TransferMode::kTransferable) {

// delegate.AddHostObject(host_object);

// continue;

// }

// }

//

// THROW_ERR_INVALID_TRANSFER_OBJECT(env);

// return Nothing<bool>();

// }

// if (delegate.AddNestedHostObjects().IsNothing())

// return Nothing<bool>();

serializer.WriteHeader();

if (serializer.WriteValue(context, input).IsNothing()) {

return Nothing<bool>();

}

for (Local<ArrayBuffer> ab : array_buffers) {

// If serialization succeeded, we render it inaccessible in this Isolate.

std::shared_ptr<BackingStore> backing_store = ab->GetBackingStore();

ab->Detach();

array_buffers_.emplace_back(std::move(backing_store));

}

// if (delegate.Finish(context).IsNothing())

// return Nothing<bool>();

// The serializer gave us a buffer allocated using `malloc()`.

std::pair<uint8_t*, size_t> data = serializer.Release();

tns::Assert(data.first != NULL, isolate);

main_message_buf_ =

MallocedBuffer<char>(reinterpret_cast<char*>(data.first), data.second);

return Just(true);

Local<Context> context) {

Context::Scope context_scope(context);

// CHECK(!IsCloseMessage());

// if (port_list != nullptr && !transferables_.empty()) {

// // Need to create this outside of the EscapableHandleScope, but inside

// // the Context::Scope.

// *port_list = Array::New(env->isolate());

// }

EscapableHandleScope handle_scope(isolate);

// Create all necessary objects for transferables, e.g. MessagePort handles.

// std::vector<BaseObjectPtr<BaseObject>>

// host_objects(transferables_.size()); auto cleanup = OnScopeLeave([&]() {

// for (BaseObjectPtr<BaseObject> object : host_objects) {

// if (!object) continue;

//

// // If the function did not finish successfully, host_objects will

// contain

// // a list of objects that will never be passed to JS. Therefore, we

// // destroy them here.

// object->Detach();

// }

// });

// for (uint32_t i = 0; i < transferables_.size(); ++i) {

// HandleScope handle_scope(env->isolate());

// TransferData* data = transferables_[i].get();

// host_objects[i] = data->Deserialize(

// env, context, std::move(transferables_[i]));

// if (!host_objects[i]) return {};

// if (port_list != nullptr) {

// // If we gather a list of all message ports, and this transferred

// object

// // is a message port, add it to that list. This is a bit of an odd

// case

// // of special handling for MessagePorts (as opposed to applying to all

// // transferables), but it's required for spec compliance.

// DCHECK((*port_list)->IsArray());

// Local<Array> port_list_array = port_list->As<Array>();

// Local<Object> obj = host_objects[i]->object();

// if (env->message_port_constructor_template()->HasInstance(obj)) {

// if (port_list_array->Set(context,

// port_list_array->Length(),

// obj).IsNothing()) {

// return {};

// }

// }

// }

// }

// transferables_.clear();

std::vector<Local<SharedArrayBuffer>> shared_array_buffers;

// Attach all transferred SharedArrayBuffers to their new Isolate.

for (uint32_t i = 0; i < shared_array_buffers_.size(); ++i) {

Local<SharedArrayBuffer> sab =

SharedArrayBuffer::New(isolate, shared_array_buffers_[i]);

shared_array_buffers.push_back(sab);

}

DeserializerDelegate delegate(

this, isolate,

// host_objects,

shared_array_buffers

// wasm_modules_,

// shared_value_conveyor_

);

ValueDeserializer deserializer(

isolate, reinterpret_cast<const uint8_t*>(main_message_buf_.data),

main_message_buf_.size, &delegate);

delegate.deserializer = &deserializer;

// Attach all transferred ArrayBuffers to their new Isolate.

for (uint32_t i = 0; i < array_buffers_.size(); ++i) {

Local<ArrayBuffer> ab =

ArrayBuffer::New(isolate, std::move(array_buffers_[i]));

deserializer.TransferArrayBuffer(i, ab);

}

if (deserializer.ReadHeader(context).IsNothing()) return {};

Local<Value> return_value;

if (!deserializer.ReadValue(context).ToLocal(&return_value)) return {};

// for (BaseObjectPtr<BaseObject> base_object : host_objects) {

// if (base_object->FinalizeTransferRead(context,

// &deserializer).IsNothing())

// return {};

// }

// host_objects.clear();

return handle_scope.Escape(return_value);