emnapi 1.9.2 → 2.0.0-alpha.1

package/src/v8/string.cc

@@ -0,0 +1,104 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_string_new_from_utf8(Isolate* isolate, const char* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_one_byte(Isolate* isolate, const uint8_t* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_two_byte(Isolate* isolate, const uint16_t* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_external_one_byte(Isolate* isolate, const char* data, int length);
+  V8_EXTERN internal::Address _v8_string_new_external_two_byte(Isolate* isolate, const uint16_t* data, int length);
+  V8_EXTERN int _v8_string_utf8_length(const String* self, Isolate* isolate);
+  V8_EXTERN int _v8_string_length(const String* self);
+  V8_EXTERN int _v8_string_write_utf8(const String* self, Isolate* isolate, char* buffer, int length, int* nchars_ref, int options);
+  V8_EXTERN internal::Address _v8_regex_new(Context* context, internal::Address pattern, int flags);
+  V8_EXTERN internal::Address _v8_string_object_new(Isolate* isolate, internal::Address value);
+  V8_EXTERN internal::Address _v8_string_object_value_of(const StringObject* self);
+}
+
+void String::CheckCast(v8::Data*) {}
+
+MaybeLocal<String> String::NewFromUtf8(v8::Isolate* isolate, char const* data, v8::NewStringType type, int length) {
+  auto str = _v8_string_new_from_utf8(isolate, data, type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_one_byte(isolate, reinterpret_cast<const uint8_t*>(data), type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewFromTwoByte(Isolate* isolate, const uint16_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_two_byte(isolate, data, type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewExternalOneByte(Isolate* isolate, ExternalOneByteStringResource* resource) {
+  auto str = _v8_string_new_external_one_byte(isolate, resource->data(), static_cast<int>(resource->length()));
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewExternalTwoByte(Isolate* isolate, ExternalStringResource* resource) {
+  auto str = _v8_string_new_external_two_byte(isolate, resource->data(), static_cast<int>(resource->length()));
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<RegExp> RegExp::New(Local<Context> context,
+                               Local<String> pattern,
+                               Flags flags) {
+  auto regex = _v8_regex_new(*context, v8impl::AddressFromV8LocalValue(pattern), flags);
+  if (!regex) return MaybeLocal<RegExp>();
+  return v8impl::V8LocalValueFromAddress(regex).As<RegExp>();
+}
+
+Local<Value> StringObject::New(Isolate* isolate, Local<String> value) {
+  auto str = _v8_string_object_new(isolate, v8impl::AddressFromV8LocalValue(value));
+  return v8impl::V8LocalValueFromAddress(str);
+}
+
+Local<String> StringObject::ValueOf() const {
+  auto str = _v8_string_object_value_of(this);
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+int String::Utf8Length(v8::Isolate* isolate) const {
+  return _v8_string_utf8_length(this, isolate);
+}
+
+int String::Length() const {
+  return _v8_string_length(this);
+}
+
+int String::WriteUtf8(Isolate* isolate, char* buffer, int length,
+                int* nchars_ref, int options) const {
+  return _v8_string_write_utf8(
+      this, isolate, buffer, length, nchars_ref, options);
+}
+
+String::Utf8Value::Utf8Value(Isolate* isolate, Local<v8::Value> obj) {
+  if (obj.IsEmpty() || !obj->IsString()) {
+    str_ = nullptr;
+    length_ = 0;
+    return;
+  }
+
+  Local<String> str = obj.As<String>();
+  length_ = str->Utf8Length(isolate);
+  str_ = new char[length_ + 1];
+  str->WriteUtf8(isolate, str_, length_ + 1);
+  str_[length_] = '\0';
+}
+
+String::Utf8Value::~Utf8Value() {
+  if (str_ == nullptr) return;
+  delete[] str_;
+  str_ = nullptr;
+  length_ = 0;
+}
+
+}

package/src/v8/template.cc

@@ -0,0 +1,234 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN Value* _v8_cbinfo_new_target(internal::Address info);
+  V8_EXTERN Value* _v8_cbinfo_holder(internal::Address info);
+  V8_EXTERN internal::Address _v8_function_template_new(
+      Isolate* isolate, internal::Address (*callback)(internal::Address info, v8::FunctionCallback cb),
+      v8::FunctionCallback cb,
+      internal::Address data, internal::Address signature,
+      int length, ConstructorBehavior behavior,
+      SideEffectType side_effect_type,
+      const CFunction* c_function, uint16_t instance_type,
+      uint16_t allowed_receiver_instance_type_range_start,
+      uint16_t allowed_receiver_instance_type_range_end);
+  V8_EXTERN internal::Address _v8_function_template_get_function(FunctionTemplate* tpl, Context* context);
+  V8_EXTERN void _v8_function_template_set_class_name(FunctionTemplate* tpl, internal::Address name);
+  V8_EXTERN int _v8_get_cb_info(internal::Address info, size_t* argc, internal::Address* argv, internal::Address* this_arg, void** data);
+  V8_EXTERN internal::Address _v8_object_template_new(Isolate* isolate, internal::Address constructor);
+  V8_EXTERN void _v8_object_template_set_internal_field_count(ObjectTemplate* obj_tpl, int value);
+  V8_EXTERN internal::Address _v8_object_template_new_instance(ObjectTemplate* obj_tpl, Context* context);
+  V8_EXTERN internal::Address _v8_signature_new(Isolate* isolate, internal::Address receiver);
+  V8_EXTERN void _v8_template_set(Template* tpl, internal::Address name, internal::Address value, 
+                                  PropertyAttribute attributes);
+  V8_EXTERN internal::Address _v8_function_template_instance_template(FunctionTemplate* tpl);
+  V8_EXTERN internal::Address _v8_function_template_prototype_template(FunctionTemplate* tpl);
+  V8_EXTERN void _v8_get_property_cb_info(internal::Address info, internal::Address* args);
+  V8_EXTERN void _v8_object_template_set_accessor(
+    ObjectTemplate* obj_tpl, internal::Address name,
+    internal::Address (*getter_wrap)(internal::Address property, internal::Address info, AccessorNameGetterCallback getter),
+    internal::Address (*setter_wrap)(internal::Address property, internal::Address value, internal::Address info, AccessorNameSetterCallback setter),
+    AccessorNameGetterCallback getter, AccessorNameSetterCallback setter,
+    internal::Address data, PropertyAttribute attribute,
+    SideEffectType getter_side_effect_type,
+    SideEffectType setter_side_effect_type
+  );
+  V8_EXTERN internal::Address _v8_function_new(
+    Context* context,
+    internal::Address (*callback)(internal::Address info, v8::FunctionCallback cb),
+    v8::FunctionCallback cb,
+    internal::Address data,
+    int length,
+    int behavior,
+    int side_effect_type);
+}
+
+namespace {
+
+struct FunctionCallbackInfoImpl {
+  internal::Address* implicit_args_;
+  internal::Address* values_;
+  int length_;
+
+  FunctionCallbackInfoImpl(internal::Address info) {
+    size_t argc = 0;
+    _v8_get_cb_info(info, &argc, nullptr, nullptr, nullptr);
+    internal::Address* list = new internal::Address[7 + argc]{0};
+    implicit_args_ = list;
+    values_ = list + 7;
+    length_ = argc;
+    _v8_get_cb_info(info, &argc, values_, list, reinterpret_cast<void**>(list + 4));
+    // *(list) = reinterpret_cast<internal::Address>(_v8_cbinfo_this(info));
+    *(list + 1) = reinterpret_cast<internal::Address>(Isolate::GetCurrent());
+    *(list + 2) = 0;
+    // *(list + 3) = reinterpret_cast<internal::Address>(_v8_cbinfo_rv(info));
+    *(list + 3) = internal::ValueHelper::kEmpty;
+    // *(list + 4) = reinterpret_cast<internal::Address>(_v8_cbinfo_data(info));
+    *(list + 5) = reinterpret_cast<internal::Address>(_v8_cbinfo_new_target(info));
+    // *(list + 6) = argc;
+    *(list + 6) = *list;
+    *(list) = reinterpret_cast<internal::Address>(_v8_cbinfo_holder(info));
+  }
+
+  FunctionCallbackInfoImpl(const FunctionCallbackInfoImpl&) = delete;
+  FunctionCallbackInfoImpl& operator=(const FunctionCallbackInfoImpl&) = delete;
+  FunctionCallbackInfoImpl(FunctionCallbackInfoImpl&&) = delete;
+  FunctionCallbackInfoImpl& operator=(FunctionCallbackInfoImpl&&) = delete;
+
+  ~FunctionCallbackInfoImpl() {
+    delete[] implicit_args_;
+  }
+};
+
+internal::Address CallbackWrap(internal::Address info, v8::FunctionCallback callback) {
+  const FunctionCallbackInfoImpl cbinfo{info};
+  const v8::FunctionCallbackInfo<Value>* args = reinterpret_cast<const v8::FunctionCallbackInfo<Value>*>(&cbinfo);
+  const v8::FunctionCallbackInfo<Value>& args_ref = *args;
+  callback(args_ref);
+  Local<Value> ret = args->GetReturnValue().Get();
+  return v8impl::AddressFromV8LocalValue(ret);
+}
+
+struct PropertyCallbackInfoImpl {
+  internal::Address* args_;
+
+  PropertyCallbackInfoImpl(internal::Address info) {
+    internal::Address* list = new internal::Address[8]{0};
+    *(list + 2) = reinterpret_cast<internal::Address>(Isolate::GetCurrent());
+    *(list + 4) = internal::ValueHelper::kEmpty;
+    _v8_get_property_cb_info(info, list);
+    args_ = list;
+  }
+
+  PropertyCallbackInfoImpl(const PropertyCallbackInfoImpl&) = delete;
+  PropertyCallbackInfoImpl& operator=(const PropertyCallbackInfoImpl&) = delete;
+  PropertyCallbackInfoImpl(PropertyCallbackInfoImpl&&) = delete;
+  PropertyCallbackInfoImpl& operator=(PropertyCallbackInfoImpl&&) = delete;
+
+  ~PropertyCallbackInfoImpl() {
+    delete[] args_;
+  }
+};
+
+internal::Address PropertyGetterWrap(internal::Address property, internal::Address info, AccessorNameGetterCallback getter) {
+  const PropertyCallbackInfoImpl cbinfo{info};
+  const v8::PropertyCallbackInfo<Value>* args = reinterpret_cast<const v8::PropertyCallbackInfo<Value>*>(&cbinfo);
+  const v8::PropertyCallbackInfo<Value>& args_ref = *args;
+  getter(v8impl::V8LocalValueFromAddress(property).As<Name>(), args_ref);
+  Local<Value> ret = args->GetReturnValue().Get();
+  return v8impl::AddressFromV8LocalValue(ret);
+}
+
+internal::Address PropertySetterWrap(internal::Address property, internal::Address value, internal::Address info, AccessorNameSetterCallback setter) {
+  const PropertyCallbackInfoImpl cbinfo{info};
+  const v8::PropertyCallbackInfo<void>* args = reinterpret_cast<const v8::PropertyCallbackInfo<void>*>(&cbinfo);
+  const v8::PropertyCallbackInfo<void>& args_ref = *args;
+  setter(v8impl::V8LocalValueFromAddress(property).As<Name>(), v8impl::V8LocalValueFromAddress(value), args_ref);
+  Local<Value> ret = args->GetReturnValue().Get();
+  return v8impl::AddressFromV8LocalValue(ret);
+}
+
+}
+
+void FunctionTemplate::CheckCast(v8::Data*) {}
+void ObjectTemplate::CheckCast(v8::Data*) {}
+
+Local<FunctionTemplate> FunctionTemplate::New(
+    Isolate* isolate, v8::FunctionCallback callback,
+    Local<Value> data,
+    Local<Signature> signature, int length,
+    ConstructorBehavior behavior,
+    SideEffectType side_effect_type,
+    const CFunction* c_function, uint16_t instance_type,
+    uint16_t allowed_receiver_instance_type_range_start,
+    uint16_t allowed_receiver_instance_type_range_end) {
+  internal::Address tpl_value = _v8_function_template_new(isolate,
+    CallbackWrap, callback, reinterpret_cast<internal::Address>(*data),
+    reinterpret_cast<internal::Address>(*signature), length,
+    behavior, side_effect_type, c_function, instance_type,
+    allowed_receiver_instance_type_range_start,
+    allowed_receiver_instance_type_range_end);
+  return v8impl::V8LocalValueFromAddress(tpl_value).As<FunctionTemplate>();
+}
+
+MaybeLocal<Function> FunctionTemplate::GetFunction(v8::Local<v8::Context> context) {
+  auto func = _v8_function_template_get_function(this, *context);
+  if (!func) return MaybeLocal<Function>();
+  return v8impl::V8LocalValueFromAddress(func).As<Function>();
+}
+
+void FunctionTemplate::SetClassName(v8::Local<v8::String> name) {
+  _v8_function_template_set_class_name(this, v8impl::AddressFromV8LocalValue(name));
+}
+
+Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {
+  internal::Address v = _v8_function_template_instance_template(this);
+  v8::Local<v8::ObjectTemplate> local;
+  memcpy(static_cast<void*>(&local), &v, sizeof(v));
+  return local;
+}
+
+Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {
+  internal::Address v = _v8_function_template_prototype_template(this);
+  v8::Local<v8::ObjectTemplate> local;
+  memcpy(static_cast<void*>(&local), &v, sizeof(v));
+  return local;
+}
+
+void Template::Set(Local<Name> name, Local<Data> value,
+                   PropertyAttribute attributes) {
+  internal::Address name_value = v8impl::AddressFromV8LocalValue(name);
+  internal::Address value_value = reinterpret_cast<internal::Address>(*value);
+  _v8_template_set(this, name_value, value_value, attributes);
+}
+
+void ObjectTemplate::SetAccessor(
+      Local<Name> name, AccessorNameGetterCallback getter,
+      AccessorNameSetterCallback setter,
+      Local<Value> data, PropertyAttribute attribute,
+      SideEffectType getter_side_effect_type,
+      SideEffectType setter_side_effect_type) {
+  _v8_object_template_set_accessor(
+    this, v8impl::AddressFromV8LocalValue(name),
+    PropertyGetterWrap, PropertySetterWrap,
+    getter, setter,
+    v8impl::AddressFromV8LocalValue(data), attribute,
+    getter_side_effect_type, setter_side_effect_type);
+}
+
+Local<Signature> Signature::New(Isolate* isolate, Local<FunctionTemplate> receiver) {
+  internal::Address signature = _v8_signature_new(isolate, reinterpret_cast<internal::Address>(*receiver));
+  return v8impl::V8LocalValueFromAddress(signature).As<Signature>();
+}
+
+Local<ObjectTemplate> ObjectTemplate::New(Isolate* isolate, Local<FunctionTemplate> constructor) {
+  internal::Address obj_tpl_value = _v8_object_template_new(isolate, reinterpret_cast<internal::Address>(*constructor));
+  if (!obj_tpl_value) return Local<ObjectTemplate>();
+  return v8impl::V8LocalValueFromAddress(obj_tpl_value).As<ObjectTemplate>();
+}
+
+MaybeLocal<Object> ObjectTemplate::NewInstance(v8::Local<v8::Context> context) {
+  internal::Address obj_value = _v8_object_template_new_instance(this, *context);
+  if (!obj_value) return MaybeLocal<Object>();
+  return v8impl::V8LocalValueFromAddress(obj_value).As<Object>();
+}
+
+void ObjectTemplate::SetInternalFieldCount(int value) {
+  _v8_object_template_set_internal_field_count(this, value);
+}
+
+MaybeLocal<Function> Function::New(
+      Local<Context> context, FunctionCallback callback,
+      Local<Value> data, int length,
+      ConstructorBehavior behavior,
+      SideEffectType side_effect_type) {
+  internal::Address func_value = _v8_function_new(
+    *context, CallbackWrap, callback, reinterpret_cast<internal::Address>(*data),
+    length, static_cast<int>(behavior), static_cast<int>(side_effect_type));
+  if (!func_value) return MaybeLocal<Function>();
+  return v8impl::V8LocalValueFromAddress(func_value).As<Function>();
+}
+
+}

package/src/v8/try_catch.cc

@@ -0,0 +1,50 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+namespace {
+
+TryCatch* current = nullptr;
+
+}
+
+extern "C" {
+  V8_EXTERN void _v8_trycatch_construct(TryCatch*);
+  V8_EXTERN void _v8_trycatch_destruct(TryCatch*);
+  V8_EXTERN bool _v8_trycatch_has_caught(const TryCatch*);
+  V8_EXTERN internal::Address _v8_trycatch_rethrow(TryCatch*);
+  V8_EXTERN internal::Address _v8_trycatch_exception(const TryCatch*);
+  V8_EXTERN void _v8_trycatch_reset(TryCatch*);
+}
+
+TryCatch::TryCatch(Isolate* isolate) {
+  this->next_ = current;
+  current = this;
+  this->i_isolate_ = reinterpret_cast<internal::Isolate*>(isolate);
+  _v8_trycatch_construct(this);
+}
+
+TryCatch::~TryCatch() {
+  if (current) {
+    current = current->next_;
+  }
+  _v8_trycatch_destruct(this);
+}
+
+bool TryCatch::HasCaught() const {
+  return _v8_trycatch_has_caught(this);
+}
+
+Local<Value> TryCatch::ReThrow() {
+  return v8impl::V8LocalValueFromAddress(_v8_trycatch_rethrow(this));
+}
+
+Local<Value> TryCatch::Exception() const {
+  return v8impl::V8LocalValueFromAddress(_v8_trycatch_exception(this));
+}
+
+void TryCatch::Reset() {
+  _v8_trycatch_reset(this);
+}
+
+}

package/src/v8/v8_impl.h

@@ -0,0 +1,42 @@
+#ifndef EMNAPI_V8_IMPL_H_
+#define EMNAPI_V8_IMPL_H_
+
+#include "v8.h"
+
+#if !defined(V8_EXTERN)
+#define V8_EXTERN __attribute__((__import_module__("env")))
+#endif
+
+namespace v8 {
+
+namespace v8impl {
+
+enum class Constant : v8::internal::Address {
+  kHole,
+  kEmpty,
+  kUndefined,
+  kNull,
+  kFalse,
+  kTrue,
+  kGlobal,
+  kEmptyString,
+};
+
+static_assert(sizeof(v8::Local<v8::Value>) == sizeof(internal::Address),
+              "Cannot convert between v8::Local<v8::Value> and internal::Address");
+
+inline internal::Address AddressFromV8LocalValue(v8::Local<v8::Value> local) {
+  return reinterpret_cast<internal::Address>(*local);
+}
+
+inline v8::Local<v8::Value> V8LocalValueFromAddress(internal::Address v) {
+  v8::Local<v8::Value> local;
+  memcpy(static_cast<void*>(&local), &v, sizeof(v));
+  return local;
+}
+
+}
+
+}
+
+#endif

package/src/v8/value.cc

@@ -0,0 +1,138 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN bool _v8_value_strict_equals(const Value*, Value*);
+  V8_EXTERN internal::Address _v8_value_to_boolean(const Value*, Isolate*);
+  V8_EXTERN internal::Address _v8_value_to_number(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_string(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_object(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_integer(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_uint32(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_int32(const Value*, Context*);
+  V8_EXTERN internal::Address _v8_value_to_array_index(const Value*, Context*);
+  V8_EXTERN bool _v8_value_is_function(const Value*);
+  V8_EXTERN bool _v8_value_is_undefined(const Value*);
+  V8_EXTERN bool _v8_value_is_null(const Value*);
+  V8_EXTERN bool _v8_value_is_true(const Value*);
+  V8_EXTERN bool _v8_value_is_false(const Value*);
+  V8_EXTERN bool _v8_value_is_string(const Value*);
+  V8_EXTERN bool _v8_value_is_number(const Value*);
+}
+
+void Value::CheckCast(Data*) {}
+
+bool Value::StrictEquals(Local<Value> that) const {
+  return _v8_value_strict_equals(this, *that);
+}
+
+Local<Boolean> Value::ToBoolean(Isolate* isolate) const {
+  return v8impl::V8LocalValueFromAddress(_v8_value_to_boolean(this, isolate)).As<Boolean>();
+}
+
+MaybeLocal<Number> Value::ToNumber(Local<Context> context) const {
+  internal::Address value = _v8_value_to_number(this, *context);
+  if (!value) return MaybeLocal<Number>();
+  return v8impl::V8LocalValueFromAddress(value).As<Number>();
+}
+
+MaybeLocal<String> Value::ToString(Local<Context> context) const {
+  internal::Address value = _v8_value_to_string(this, *context);
+  if (!value) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(value).As<String>();
+}
+
+MaybeLocal<String> Value::ToDetailString(Local<Context> context) const {
+  return ToString(context);
+}
+
+bool Value::FullIsUndefined() const {
+  return _v8_value_is_undefined(this);
+}
+
+bool Value::FullIsNull() const {
+  return _v8_value_is_null(this);
+}
+
+bool Value::FullIsTrue() const {
+  return _v8_value_is_true(this);
+}
+
+bool Value::FullIsFalse() const {
+  return _v8_value_is_false(this);
+}
+
+bool Value::FullIsString() const {
+  return _v8_value_is_string(this);
+}
+
+bool Value::IsFunction() const {
+  return _v8_value_is_function(this);
+}
+
+bool Value::IsNumber() const {
+  return _v8_value_is_number(this);
+}
+
+MaybeLocal<Object> Value::ToObject(Local<Context> context) const {
+  internal::Address value = _v8_value_to_object(this, *context);
+  if (!value) return MaybeLocal<Object>();
+  return v8impl::V8LocalValueFromAddress(value).As<Object>();
+}
+
+MaybeLocal<Integer> Value::ToInteger(Local<Context> context) const {
+  internal::Address value = _v8_value_to_integer(this, *context);
+  if (!value) return MaybeLocal<Integer>();
+  return v8impl::V8LocalValueFromAddress(value).As<Integer>();
+}
+
+MaybeLocal<Uint32> Value::ToUint32(Local<Context> context) const {
+  internal::Address value = _v8_value_to_uint32(this, *context);
+  if (!value) return MaybeLocal<Uint32>();
+  return v8impl::V8LocalValueFromAddress(value).As<Uint32>();
+}
+
+MaybeLocal<Int32> Value::ToInt32(Local<Context> context) const {
+  internal::Address value = _v8_value_to_int32(this, *context);
+  if (!value) return MaybeLocal<Int32>();
+  return v8impl::V8LocalValueFromAddress(value).As<Int32>();
+}
+
+MaybeLocal<Uint32> Value::ToArrayIndex(Local<Context> context) const {
+  internal::Address value = _v8_value_to_array_index(this, *context);
+  if (!value) return MaybeLocal<Uint32>();
+  return v8impl::V8LocalValueFromAddress(value).As<Uint32>();
+}
+
+bool Value::BooleanValue(Isolate* isolate) const {
+  return ToBoolean(isolate)->Value();
+}
+
+Maybe<double> Value::NumberValue(Local<Context> context) const {
+  auto maybe = ToNumber(context);
+  if (maybe.IsEmpty()) return Nothing<double>();
+  return Just<double>(maybe.ToLocalChecked()->Value());
+}
+
+Maybe<int64_t> Value::IntegerValue(Local<Context> context) const {
+  auto maybe = ToInteger(context);
+  if (maybe.IsEmpty()) return Nothing<int64_t>();
+  return Just<int64_t>(maybe.ToLocalChecked()->Value());
+}
+
+Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const {
+  auto maybe = ToUint32(context);
+  if (maybe.IsEmpty()) return Nothing<uint32_t>();
+  return Just<uint32_t>(maybe.ToLocalChecked()->Value());
+}
+
+Maybe<int32_t> Value::Int32Value(Local<Context> context) const {
+  auto maybe = ToInt32(context);
+  if (maybe.IsEmpty()) return Nothing<int32_t>();
+  return Just<int32_t>(maybe.ToLocalChecked()->Value());
+}
+
+
+
+}