// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "util.h"  // NOLINT(build/include_inline)

#include <cmath>

#include <cstdint>

#include "util-inl.h"

#include "debug_utils-inl.h"

#include "env-inl.h"

#include "node_buffer.h"

#include "node_errors.h"

#include "node_internals.h"

#include "node_snapshot_builder.h"

#include "node_v8_platform-inl.h"

#include "string_bytes.h"

#include "v8-value.h"

#ifdef _WIN32

#include <io.h>  // _S_IREAD _S_IWRITE

#include <time.h>

#ifndef S_IRUSR

#define S_IRUSR _S_IREAD

#endif  // S_IRUSR

#ifndef S_IWUSR

#define S_IWUSR _S_IWRITE

#endif  // S_IWUSR

#else

#include <sys/time.h>

#include <sys/types.h>

#endif

#include <simdutf.h>

#include <atomic>

#include <cstdio>

#include <cstring>

#include <iomanip>

#include <sstream>

static std::atomic_int seq = {0};  // Sequence number for diagnostic filenames.

// F_OK etc. constants

#ifdef _WIN32

#include "uv.h"

#else

#include <unistd.h>

#endif

// The access modes can be any of F_OK, R_OK, W_OK or X_OK. Some might not be

// available on specific systems. They can be used in combination as well

// (F_OK | R_OK | W_OK | X_OK).

constexpr int kMaximumAccessMode = F_OK | W_OK | R_OK | X_OK;

constexpr int kMinimumAccessMode = std::min({F_OK, W_OK, R_OK, X_OK});

constexpr int kDefaultCopyMode = 0;

// The copy modes can be any of UV_FS_COPYFILE_EXCL, UV_FS_COPYFILE_FICLONE or

// UV_FS_COPYFILE_FICLONE_FORCE. They can be used in combination as well

// (US_FS_COPYFILE_EXCL | US_FS_COPYFILE_FICLONE |

// US_FS_COPYFILE_FICLONE_FORCE).

constexpr int kMinimumCopyMode = std::min({kDefaultCopyMode,

                                           UV_FS_COPYFILE_EXCL,

                                           UV_FS_COPYFILE_FICLONE,

                                           UV_FS_COPYFILE_FICLONE_FORCE});

constexpr int kMaximumCopyMode =

    UV_FS_COPYFILE_EXCL | UV_FS_COPYFILE_FICLONE | UV_FS_COPYFILE_FICLONE_FORCE;

namespace node {

using v8::ArrayBuffer;

using v8::ArrayBufferView;

using v8::Context;

using v8::FunctionTemplate;

using v8::Isolate;

using v8::Local;

using v8::Object;

using v8::String;

using v8::Template;

using v8::Value;

template <typename T>

static void MakeUtf8String(Isolate* isolate,

                           Local<Value> value,

                           MaybeStackBuffer<T>* target) {

  Local<String> string;

  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  String::ValueView value_view(isolate, string);

  auto value_length = value_view.length();

  if (value_view.is_one_byte()) {

    auto const_char = reinterpret_cast<const char*>(value_view.data8());

    auto expected_length =

        target->capacity() < (static_cast<size_t>(value_length) * 2 + 1)

            ? simdutf::utf8_length_from_latin1(const_char, value_length)

            : value_length * 2;

    // Add +1 for null termination.

    target->AllocateSufficientStorage(expected_length + 1);

    const auto actual_length = simdutf::convert_latin1_to_utf8(

        const_char, value_length, target->out());

    target->SetLengthAndZeroTerminate(actual_length);

    return;

  }

  // Add +1 for null termination.

  size_t storage = (3 * value_length) + 1;

  target->AllocateSufficientStorage(storage);

  size_t length = string->WriteUtf8V2(

      isolate, target->out(), storage, String::WriteFlags::kReplaceInvalidUtf8);

  target->SetLengthAndZeroTerminate(length);

}

Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {

  if (value.IsEmpty())

    return;

  MakeUtf8String(isolate, value, this);

}

TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {

  if (value.IsEmpty()) {

    return;

  }

  Local<String> string;

  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  // Allocate enough space to include the null terminator.

  const size_t length = string->Length();

  AllocateSufficientStorage(length + 1);

  string->WriteV2(isolate, 0, length, out());

  SetLengthAndZeroTerminate(length);

}

BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {

  // Slightly different take on Utf8Value. If value is a String,

  // it will return a Utf8 encoded string. If value is a Buffer,

  // it will copy the data out of the Buffer as is.

  if (value.IsEmpty()) {

    // Dereferencing this object will return nullptr.

    Invalidate();

    return;

  }

  if (value->IsString()) {

    MakeUtf8String(isolate, value, this);

  } else if (value->IsArrayBufferView()) {

    const size_t len = value.As<ArrayBufferView>()->ByteLength();

    // Leave place for the terminating '\0' byte.

    AllocateSufficientStorage(len + 1);

    value.As<ArrayBufferView>()->CopyContents(out(), len);

    SetLengthAndZeroTerminate(len);

  } else {

    Invalidate();

  }

}

void LowMemoryNotification() {

  if (per_process::v8_initialized) {

    auto isolate = Isolate::TryGetCurrent();

    if (isolate != nullptr) {

      isolate->LowMemoryNotification();

    }

  }

}

std::string GetProcessTitle(const char* default_title) {

  std::string buf(16, '\0');

  for (;;) {

    const int rc = uv_get_process_title(buf.data(), buf.size());

    if (rc == 0)

      break;

    // If uv_setup_args() was not called, `uv_get_process_title()` will always

    // return `UV_ENOBUFS`, no matter the input size. Guard against a possible

    // infinite loop by limiting the buffer size.

    if (rc != UV_ENOBUFS || buf.size() >= 1024 * 1024)

      return default_title;

    buf.resize(2 * buf.size());

  }

  // Strip excess trailing nul bytes. Using strlen() here is safe,

  // uv_get_process_title() always zero-terminates the result.

  buf.resize(strlen(buf.data()));

  return buf;

}

std::string GetHumanReadableProcessName() {

  return SPrintF("%s[%d]", GetProcessTitle("Node.js"), uv_os_getpid());

}

void ThrowErrStringTooLong(Isolate* isolate) {

  isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));

}

double GetCurrentTimeInMicroseconds() {

  constexpr double kMicrosecondsPerSecond = 1e6;

  uv_timeval64_t tv;

  CHECK_EQ(0, uv_gettimeofday(&tv));

  return kMicrosecondsPerSecond * tv.tv_sec + tv.tv_usec;

}

int WriteFileSync(const char* path, uv_buf_t buf) {

  return WriteFileSync(path, &buf, 1);

}

int WriteFileSync(const char* path, uv_buf_t* bufs, size_t buf_count) {

  uv_fs_t req;

  int fd = uv_fs_open(nullptr,

                      &req,

                      path,

                      O_WRONLY | O_CREAT | O_TRUNC,

                      S_IWUSR | S_IRUSR,

                      nullptr);

  uv_fs_req_cleanup(&req);

  if (fd < 0) {

    return fd;

  }

  int err = uv_fs_write(nullptr, &req, fd, bufs, buf_count, 0, nullptr);

  uv_fs_req_cleanup(&req);

  if (err < 0) {

    return err;

  }

  err = uv_fs_close(nullptr, &req, fd, nullptr);

  uv_fs_req_cleanup(&req);

  return err;

}

int WriteFileSync(v8::Isolate* isolate,

                  const char* path,

                  v8::Local<v8::String> string) {

  node::Utf8Value utf8(isolate, string);

  uv_buf_t buf = uv_buf_init(utf8.out(), utf8.length());

  return WriteFileSync(path, buf);

}

int ReadFileSync(std::string* result, const char* path) {

  uv_fs_t req;

  auto defer_req_cleanup = OnScopeLeave([&req]() {

    uv_fs_req_cleanup(&req);

  });

  uv_file file = uv_fs_open(nullptr, &req, path, O_RDONLY, 0, nullptr);

  if (req.result < 0) {

    // req will be cleaned up by scope leave.

    return req.result;

  }

  uv_fs_req_cleanup(&req);

  auto defer_close = OnScopeLeave([file]() {

    uv_fs_t close_req;

    CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));

    uv_fs_req_cleanup(&close_req);

  });

  *result = std::string("");

  char buffer[4096];

  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));

  while (true) {

    const int r =

        uv_fs_read(nullptr, &req, file, &buf, 1, result->length(), nullptr);

    if (req.result < 0) {

      // req will be cleaned up by scope leave.

      return req.result;

    }

    uv_fs_req_cleanup(&req);

    if (r <= 0) {

      break;

    }

    result->append(buf.base, r);

  }

  return 0;

}

std::vector<char> ReadFileSync(FILE* fp) {

  CHECK_EQ(ftell(fp), 0);

  int err = fseek(fp, 0, SEEK_END);

  CHECK_EQ(err, 0);

  size_t size = ftell(fp);

  CHECK_NE(size, static_cast<size_t>(-1L));

  err = fseek(fp, 0, SEEK_SET);

  CHECK_EQ(err, 0);

  std::vector<char> contents(size);

  size_t num_read = fread(contents.data(), size, 1, fp);

  CHECK_EQ(num_read, 1);

  return contents;

}

void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {

#ifdef _WIN32

  GetLocalTime(tm_struct);

#else  // UNIX, macOS

  struct timeval time_val;

  gettimeofday(&time_val, nullptr);

  localtime_r(&time_val.tv_sec, tm_struct);

#endif

}

// Defined in node_internals.h

std::string DiagnosticFilename::MakeFilename(

    uint64_t thread_id,

    const char* prefix,

    const char* ext) {

  std::ostringstream oss;

  TIME_TYPE tm_struct;

  LocalTime(&tm_struct);

  oss << prefix;

#ifdef _WIN32

  oss << "." << std::setfill('0') << std::setw(4) << tm_struct.wYear;

  oss << std::setfill('0') << std::setw(2) << tm_struct.wMonth;

  oss << std::setfill('0') << std::setw(2) << tm_struct.wDay;

  oss << "." << std::setfill('0') << std::setw(2) << tm_struct.wHour;

  oss << std::setfill('0') << std::setw(2) << tm_struct.wMinute;

  oss << std::setfill('0') << std::setw(2) << tm_struct.wSecond;

#else  // UNIX, macOS

  oss << "."

            << std::setfill('0')

            << std::setw(4)

            << tm_struct.tm_year + 1900;

  oss << std::setfill('0')

            << std::setw(2)

            << tm_struct.tm_mon + 1;

  oss << std::setfill('0')

            << std::setw(2)

            << tm_struct.tm_mday;

  oss << "."

            << std::setfill('0')

            << std::setw(2)

            << tm_struct.tm_hour;

  oss << std::setfill('0')

            << std::setw(2)

            << tm_struct.tm_min;

  oss << std::setfill('0')

            << std::setw(2)

            << tm_struct.tm_sec;

#endif

  oss << "." << uv_os_getpid();

  oss << "." << thread_id;

  oss << "." << std::setfill('0') << std::setw(3) << ++seq;

  oss << "." << ext;

  return oss.str();

}

Local<v8::FunctionTemplate> NewFunctionTemplate(

    v8::Isolate* isolate,

    v8::FunctionCallback callback,

    Local<v8::Signature> signature,

    v8::ConstructorBehavior behavior,

    v8::SideEffectType side_effect_type,

    const v8::CFunction* c_function) {

  return v8::FunctionTemplate::New(isolate,

                                   callback,

                                   Local<v8::Value>(),

                                   signature,

                                   0,

                                   behavior,

                                   side_effect_type,

                                   c_function);

}

void SetMethod(Local<v8::Context> context,

               Local<v8::Object> that,

               const std::string_view name,

               v8::FunctionCallback callback) {

  Isolate* isolate = Isolate::GetCurrent();

  Local<v8::Function> function =

      NewFunctionTemplate(isolate,

                          callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect)

          ->GetFunction(context)

          .ToLocalChecked();

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(context, name_string, function).Check();

  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.

}

void SetMethod(v8::Isolate* isolate,

               v8::Local<v8::Template> that,

               const std::string_view name,

               v8::FunctionCallback callback) {

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetFastMethod(Isolate* isolate,

                   Local<Template> that,

                   const std::string_view name,

                   v8::FunctionCallback slow_callback,

                   const v8::CFunction* c_function) {

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          slow_callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect,

                          c_function);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetFastMethod(Local<v8::Context> context,

                   Local<v8::Object> that,

                   const std::string_view name,

                   v8::FunctionCallback slow_callback,

                   const v8::CFunction* c_function) {

  Isolate* isolate = Isolate::GetCurrent();

  Local<v8::Function> function =

      NewFunctionTemplate(isolate,

                          slow_callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect,

                          c_function)

          ->GetFunction(context)

          .ToLocalChecked();

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(context, name_string, function).Check();

}

void SetFastMethodNoSideEffect(Local<v8::Context> context,

                               Local<v8::Object> that,

                               const std::string_view name,

                               v8::FunctionCallback slow_callback,

                               const v8::CFunction* c_function) {

  Isolate* isolate = Isolate::GetCurrent();

  Local<v8::Function> function =

      NewFunctionTemplate(isolate,

                          slow_callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasNoSideEffect,

                          c_function)

          ->GetFunction(context)

          .ToLocalChecked();

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(context, name_string, function).Check();

}

void SetFastMethodNoSideEffect(Isolate* isolate,

                               Local<Template> that,

                               const std::string_view name,

                               v8::FunctionCallback slow_callback,

                               const v8::CFunction* c_function) {

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          slow_callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasNoSideEffect,

                          c_function);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetFastMethod(Isolate* isolate,

                   Local<Template> that,

                   const std::string_view name,

                   v8::FunctionCallback slow_callback,

                   const v8::MemorySpan<const v8::CFunction>& methods) {

  Local<v8::FunctionTemplate> t = FunctionTemplate::NewWithCFunctionOverloads(

      isolate,

      slow_callback,

      Local<Value>(),

      Local<v8::Signature>(),

      0,

      v8::ConstructorBehavior::kThrow,

      v8::SideEffectType::kHasSideEffect,

      methods);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetFastMethodNoSideEffect(

    Isolate* isolate,

    Local<Template> that,

    const std::string_view name,

    v8::FunctionCallback slow_callback,

    const v8::MemorySpan<const v8::CFunction>& methods) {

  Local<v8::FunctionTemplate> t = FunctionTemplate::NewWithCFunctionOverloads(

      isolate,

      slow_callback,

      Local<Value>(),

      Local<v8::Signature>(),

      0,

      v8::ConstructorBehavior::kThrow,

      v8::SideEffectType::kHasNoSideEffect,

      methods);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetMethodNoSideEffect(Local<v8::Context> context,

                           Local<v8::Object> that,

                           const std::string_view name,

                           v8::FunctionCallback callback) {

  Isolate* isolate = Isolate::GetCurrent();

  Local<v8::Function> function =

      NewFunctionTemplate(isolate,

                          callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasNoSideEffect)

          ->GetFunction(context)

          .ToLocalChecked();

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(context, name_string, function).Check();

  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.

}

void SetMethodNoSideEffect(Isolate* isolate,

                           Local<v8::Template> that,

                           const std::string_view name,

                           v8::FunctionCallback callback) {

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          Local<v8::Signature>(),

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasNoSideEffect);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->Set(name_string, t);

}

void SetProtoDispose(v8::Isolate* isolate,

                     v8::Local<v8::FunctionTemplate> that,

                     v8::FunctionCallback callback) {

  Local<v8::Signature> signature = v8::Signature::New(isolate, that);

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          signature,

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect);

  that->PrototypeTemplate()->Set(v8::Symbol::GetDispose(isolate), t);

}

void SetProtoAsyncDispose(v8::Isolate* isolate,

                          v8::Local<v8::FunctionTemplate> that,

                          v8::FunctionCallback callback) {

  Local<v8::Signature> signature = v8::Signature::New(isolate, that);

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          signature,

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect);

  that->PrototypeTemplate()->Set(v8::Symbol::GetAsyncDispose(isolate), t);

}

void SetProtoMethod(v8::Isolate* isolate,

                    Local<v8::FunctionTemplate> that,

                    const std::string_view name,

                    v8::FunctionCallback callback) {

  Local<v8::Signature> signature = v8::Signature::New(isolate, that);

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          signature,

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->PrototypeTemplate()->Set(name_string, t);

  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.

}

void SetProtoMethodNoSideEffect(v8::Isolate* isolate,

                                Local<v8::FunctionTemplate> that,

                                const std::string_view name,

                                v8::FunctionCallback callback) {

  Local<v8::Signature> signature = v8::Signature::New(isolate, that);

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          signature,

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasNoSideEffect);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->PrototypeTemplate()->Set(name_string, t);

  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.

}

void SetInstanceMethod(v8::Isolate* isolate,

                       Local<v8::FunctionTemplate> that,

                       const std::string_view name,

                       v8::FunctionCallback callback) {

  Local<v8::Signature> signature = v8::Signature::New(isolate, that);

  Local<v8::FunctionTemplate> t =

      NewFunctionTemplate(isolate,

                          callback,

                          signature,

                          v8::ConstructorBehavior::kThrow,

                          v8::SideEffectType::kHasSideEffect);

  // kInternalized strings are created in the old space.

  const v8::NewStringType type = v8::NewStringType::kInternalized;

  Local<v8::String> name_string =

      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())

          .ToLocalChecked();

  that->InstanceTemplate()->Set(name_string, t);

  t->SetClassName(name_string);

}

void SetConstructorFunction(Local<v8::Context> context,

                            Local<v8::Object> that,

                            const char* name,

                            Local<v8::FunctionTemplate> tmpl,

                            SetConstructorFunctionFlag flag) {

  Isolate* isolate = Isolate::GetCurrent();

  SetConstructorFunction(

      context, that, OneByteString(isolate, name), tmpl, flag);

}

void SetConstructorFunction(Local<Context> context,

                            Local<Object> that,

                            Local<String> name,

                            Local<FunctionTemplate> tmpl,

                            SetConstructorFunctionFlag flag) {

  if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME) [[likely]] {

    tmpl->SetClassName(name);

  }

  that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();

}

void SetConstructorFunction(Isolate* isolate,

                            Local<Template> that,

                            const char* name,

                            Local<FunctionTemplate> tmpl,

                            SetConstructorFunctionFlag flag) {

  SetConstructorFunction(

      isolate, that, OneByteString(isolate, name), tmpl, flag);

}

void SetConstructorFunction(Isolate* isolate,

                            Local<Template> that,

                            Local<String> name,

                            Local<FunctionTemplate> tmpl,

                            SetConstructorFunctionFlag flag) {

  if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME) [[likely]] {

    tmpl->SetClassName(name);

  }

  that->Set(name, tmpl);

}

Local<String> UnionBytes::ToStringChecked(Isolate* isolate) const {

  if (is_one_byte()) {

    return String::NewExternalOneByte(isolate, one_byte_resource_)

        .ToLocalChecked();

  } else {

    return String::NewExternalTwoByte(isolate, two_byte_resource_)

        .ToLocalChecked();

  }

}

RAIIIsolateWithoutEntering::RAIIIsolateWithoutEntering(const SnapshotData* data)

    : allocator_{ArrayBuffer::Allocator::NewDefaultAllocator()} {

  isolate_ = Isolate::Allocate();

  CHECK_NOT_NULL(isolate_);

  per_process::v8_platform.Platform()->RegisterIsolate(isolate_,

                                                       uv_default_loop());

  Isolate::CreateParams params;

  if (data != nullptr) {

    SnapshotBuilder::InitializeIsolateParams(data, &params);

  }

  params.array_buffer_allocator = allocator_.get();

  params.cpp_heap = v8::CppHeap::Create(per_process::v8_platform.Platform(),

                                        v8::CppHeapCreateParams{{}})

                        .release();

  Isolate::Initialize(isolate_, params);

}

RAIIIsolateWithoutEntering::~RAIIIsolateWithoutEntering() {

  per_process::v8_platform.Platform()->DisposeIsolate(isolate_);

}

RAIIIsolate::RAIIIsolate(const SnapshotData* data)

    : isolate_{data}, isolate_scope_{isolate_.get()} {}

RAIIIsolate::~RAIIIsolate() {}

// Returns a string representation of the input value, including type.

// JavaScript implementation is available in lib/internal/errors.js

std::string DetermineSpecificErrorType(Environment* env,

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

  if (input->IsFunction()) {

    return "function";

  } else if (input->IsString()) {

    auto value = Utf8Value(env->isolate(), input).ToString();

    if (value.size() > 28) {

      value = value.substr(0, 25) + "...";

    }

    if (value.find('\'') == std::string::npos) {

      return SPrintF("type string ('%s')", value);

    }

    // Stringify the input value.

    Local<String> stringified =

        v8::JSON::Stringify(env->context(), input).ToLocalChecked();

    Utf8Value stringified_value(env->isolate(), stringified);

    return SPrintF("type string (%s)", stringified_value.out());

  } else if (input->IsObject()) {

    v8::Local<v8::String> constructor_name =

        input.As<v8::Object>()->GetConstructorName();

    Utf8Value name(env->isolate(), constructor_name);

    return SPrintF("an instance of %s", name.out());

  } else if (input->IsSymbol()) {

    v8::MaybeLocal<v8::String> str =

        input.As<v8::Symbol>()->ToDetailString(env->context());

    v8::Local<v8::String> js_str;

    if (!str.ToLocal(&js_str)) {

      return "Symbol";

    }

    Utf8Value name(env->isolate(), js_str);

    // Symbol(xxx)

    return name.out();

  }

  Utf8Value utf8_value(env->isolate(),

                       input->ToString(env->context()).ToLocalChecked());

  if (input->IsNumber() || input->IsInt32() || input->IsUint32()) {

    auto value = input.As<v8::Number>()->Value();

    if (std::isnan(value)) {

      return "type number (NaN)";

    } else if (std::isinf(value)) {

      return "type number (Infinity)";

    }

    return SPrintF("type number (%s)", utf8_value.out());

  } else if (input->IsBigInt() || input->IsBoolean() || input->IsSymbol()) {

    Utf8Value type(env->isolate(), input->TypeOf(env->isolate()));

    return SPrintF("type %s (%s)", type.out(), utf8_value.out());

  }

  // For example: null, undefined

  return utf8_value.ToString();

}

v8::Maybe<int32_t> GetValidatedFd(Environment* env,

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

  if (!input->IsInt32() && !input->IsNumber()) {

    std::string error_type = node::DetermineSpecificErrorType(env, input);

    THROW_ERR_INVALID_ARG_TYPE(env,

                               "The \"fd\" argument must be of type "

                               "number. Received %s",

                               error_type.c_str());

    return v8::Nothing<int32_t>();

  }

  const double fd = input.As<v8::Number>()->Value();

  const bool is_out_of_range = fd < 0 || fd > INT32_MAX;

  if (is_out_of_range || !IsSafeJsInt(input)) {

    Local<String> str;

    if (!input->ToDetailString(env->context()).ToLocal(&str)) {

      return v8::Nothing<int32_t>();

    }

    Utf8Value utf8_value(env->isolate(), str);

    if (is_out_of_range && !std::isinf(fd)) {

      THROW_ERR_OUT_OF_RANGE(env,

                             "The value of \"fd\" is out of range. "

                             "It must be >= 0 && <= %s. Received %s",

                             std::to_string(INT32_MAX),

                             utf8_value.out());

    } else {

      THROW_ERR_OUT_OF_RANGE(

          env,

          "The value of \"fd\" is out of range. It must be an integer. "

          "Received %s",

          utf8_value.out());

    }

    return v8::Nothing<int32_t>();

  }

  return v8::Just(static_cast<int32_t>(fd));

}

v8::Maybe<int> GetValidFileMode(Environment* env,

                                v8::Local<v8::Value> input,

                                uv_fs_type type) {

  // Allow only int32 or null/undefined values.

  if (input->IsNumber()) {

    // We cast the input to v8::Number to avoid overflows.

    auto num = input.As<v8::Number>()->Value();

    // Handle infinity and NaN values

    if (std::isinf(num) || std::isnan(num)) {

      THROW_ERR_OUT_OF_RANGE(env, "mode is out of range");

      return v8::Nothing<int>();

    }

  } else if (!input->IsNullOrUndefined()) {

    THROW_ERR_INVALID_ARG_TYPE(env, "mode must be int32 or null/undefined");

    return v8::Nothing<int>();

  }

  int min = kMinimumAccessMode;

  int max = kMaximumAccessMode;

  int def = F_OK;

  CHECK(type == UV_FS_ACCESS || type == UV_FS_COPYFILE);

  if (type == UV_FS_COPYFILE) {

    min = kMinimumCopyMode;

    max = kMaximumCopyMode;

    def = input->IsNullOrUndefined() ? kDefaultCopyMode

                                     : input.As<v8::Int32>()->Value();

  }

  if (input->IsNullOrUndefined()) {

    return v8::Just(def);

  }

  const int mode = input.As<v8::Int32>()->Value();

  if (mode < min || mode > max) {

    THROW_ERR_OUT_OF_RANGE(

        env, "mode is out of range: >= %d && <= %d", min, max);

    return v8::Nothing<int>();

  }

  return v8::Just(mode);

}

}  // namespace node