v8::Local<v8::Object> object,

InternalFieldInfo* info)

: SnapshotableObject(realm, object, type_int),

encode_into_results_buffer_(

realm->isolate(),

kEncodeIntoResultsLength,

MAYBE_FIELD_PTR(info, encode_into_results_buffer)) {

if (info == nullptr) {

object

->Set(realm->context(),

FIXED_ONE_BYTE_STRING(realm->isolate(), "encodeIntoResults"),

encode_into_results_buffer_.GetJSArray())

.Check();

} else {

encode_into_results_buffer_.Deserialize(realm->context());

}

encode_into_results_buffer_.MakeWeak();

v8::SnapshotCreator* creator) {

DCHECK_NULL(internal_field_info_);

internal_field_info_ = InternalFieldInfoBase::New<InternalFieldInfo>(type());

internal_field_info_->encode_into_results_buffer =

encode_into_results_buffer_.Serialize(context, creator);

// Return true because we need to maintain the reference to the binding from

// JS land.

return true;

Local<Object> holder,

int index,

InternalFieldInfoBase* info) {

DCHECK_IS_SNAPSHOT_SLOT(index);

v8::HandleScope scope(context->GetIsolate());

Realm* realm = Realm::GetCurrent(context);

// Recreate the buffer in the constructor.

InternalFieldInfo* casted_info = static_cast<InternalFieldInfo*>(info);

BindingData* binding =

realm->AddBindingData<BindingData>(holder, casted_info);

CHECK_NOT_NULL(binding);

CHECK_GE(args.Length(), 2);

CHECK(args[0]->IsString());

CHECK(args[1]->IsUint8Array());

Realm* realm = Realm::GetCurrent(args);

Isolate* isolate = realm->isolate();

BindingData* binding_data = realm->GetBindingData<BindingData>();

Local<String> source = args[0].As<String>();

Local<Uint8Array> dest = args[1].As<Uint8Array>();

Local<ArrayBuffer> buf = dest->Buffer();

char* write_result = static_cast<char*>(buf->Data()) + dest->ByteOffset();

size_t dest_length = dest->ByteLength();

int nchars;

int written = source->WriteUtf8(

isolate,

write_result,

dest_length,

&nchars,

String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8);

binding_data->encode_into_results_buffer_[0] = nchars;

binding_data->encode_into_results_buffer_[1] = written;

Environment* env = Environment::GetCurrent(args);

Isolate* isolate = env->isolate();

CHECK_GE(args.Length(), 1);

CHECK(args[0]->IsString());

Local<String> str = args[0].As<String>();

size_t length = str->Utf8Length(isolate);

Local<ArrayBuffer> ab;

{

std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(

isolate, length, BackingStoreInitializationMode::kUninitialized);

CHECK(bs);

str->WriteUtf8(isolate,

static_cast<char*>(bs->Data()),

-1, // We are certain that `data` is sufficiently large

nullptr,

String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8);

ab = ArrayBuffer::New(isolate, std::move(bs));

}

args.GetReturnValue().Set(Uint8Array::New(ab, 0, length));

Environment* env = Environment::GetCurrent(args); // list, flags

CHECK_GE(args.Length(), 1);

if (!(args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer() ||

args[0]->IsArrayBufferView())) {

return node::THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"list\" argument must be an instance of SharedArrayBuffer, "

"ArrayBuffer or ArrayBufferView.");

}

ArrayBufferViewContents<char> buffer(args[0]);

bool ignore_bom = args[1]->IsTrue();

bool has_fatal = args[2]->IsTrue();

const char* data = buffer.data();

size_t length = buffer.length();

if (has_fatal) {

auto result = simdutf::validate_utf8_with_errors(data, length);

if (result.error) {

return node::THROW_ERR_ENCODING_INVALID_ENCODED_DATA(

env->isolate(), "The encoded data was not valid for encoding utf-8");

}

}

if (!ignore_bom && length >= 3) {

if (memcmp(data, "\xEF\xBB\xBF", 3) == 0) {

data += 3;

length -= 3;

}

}

if (length == 0) return args.GetReturnValue().SetEmptyString();

Local<Value> error;

Local<Value> ret;

if (!StringBytes::Encode(env->isolate(), data, length, UTF8, &error)

.ToLocal(&ret)) {

CHECK(!error.IsEmpty());

env->isolate()->ThrowException(error);

return;

}

args.GetReturnValue().Set(ret);

Environment* env = Environment::GetCurrent(args);

CHECK_GE(args.Length(), 1);

CHECK(args[0]->IsString());

Utf8Value input(env->isolate(), args[0]);

auto out = ada::idna::to_ascii(input.ToStringView());

Local<Value> ret;

if (ToV8Value(env->context(), out, env->isolate()).ToLocal(&ret)) {

args.GetReturnValue().Set(ret);

}

Environment* env = Environment::GetCurrent(args);

CHECK_GE(args.Length(), 1);

CHECK(args[0]->IsString());

Utf8Value input(env->isolate(), args[0]);

auto out = ada::idna::to_unicode(input.ToStringView());

Local<Value> ret;

if (ToV8Value(env->context(), out, env->isolate()).ToLocal(&ret)) {

args.GetReturnValue().Set(ret);

}

Local<ObjectTemplate> target) {

Isolate* isolate = isolate_data->isolate();

SetMethod(isolate, target, "encodeInto", EncodeInto);

SetMethodNoSideEffect(isolate, target, "encodeUtf8String", EncodeUtf8String);

SetMethodNoSideEffect(isolate, target, "decodeUTF8", DecodeUTF8);

SetMethodNoSideEffect(isolate, target, "toASCII", ToASCII);

SetMethodNoSideEffect(isolate, target, "toUnicode", ToUnicode);

SetMethodNoSideEffect(isolate, target, "decodeLatin1", DecodeLatin1);

Local<Value> unused,

Local<Context> context,

void* priv) {

Realm* realm = Realm::GetCurrent(context);

realm->AddBindingData<BindingData>(target);

ExternalReferenceRegistry* registry) {

registry->Register(EncodeInto);

registry->Register(EncodeUtf8String);

registry->Register(DecodeUTF8);

registry->Register(ToASCII);

registry->Register(ToUnicode);

registry->Register(DecodeLatin1);

Environment* env = Environment::GetCurrent(args);

CHECK_GE(args.Length(), 1);

if (!(args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer() ||

args[0]->IsArrayBufferView())) {

return node::THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"input\" argument must be an instance of ArrayBuffer, "

"SharedArrayBuffer, or ArrayBufferView.");

}

bool ignore_bom = args[1]->IsTrue();

bool has_fatal = args[2]->IsTrue();

ArrayBufferViewContents<uint8_t> buffer(args[0]);

const uint8_t* data = buffer.data();

size_t length = buffer.length();

if (ignore_bom && length > 0 && data[0] == 0xFF) {

data++;

length--;

}

if (length == 0) {

return args.GetReturnValue().SetEmptyString();

}

std::string result(length * 2, '\0');

size_t written = simdutf::convert_latin1_to_utf8(

reinterpret_cast<const char*>(data), length, result.data());

if (has_fatal && written == 0) {

return node::THROW_ERR_ENCODING_INVALID_ENCODED_DATA(

env->isolate(), "The encoded data was not valid for encoding latin1");

}

std::string_view view(result.c_str(), written);

Local<Value> ret;

if (ToV8Value(env->context(), view, env->isolate()).ToLocal(&ret)) {

args.GetReturnValue().Set(ret);

}