@isolated-vm/experimental 0.0.9 → 0.0.11

package/addon/transfer/visit.cc

@@ -7,7 +7,7 @@ import util;
 namespace isolated_vm {
 using namespace js;
 
-constexpr auto primitive_typeofs = std::array{
+constexpr auto primitive_typeofs = util::constexpr_array{
 	value_typeof::undefined,
 	value_typeof::null,
 	value_typeof::boolean,
@@ -20,12 +20,12 @@ constexpr auto primitive_typeofs = std::array{
 	value_typeof::bigint_i64,
 };
 
-constexpr auto data_block_typeofs = std::array{
+constexpr auto data_block_typeofs = util::constexpr_array{
 	value_typeof::array_buffer,
 	value_typeof::shared_array_buffer,
 };
 
-constexpr auto array_buffer_view_typeofs = std::array{
+constexpr auto array_buffer_view_typeofs = util::constexpr_array{
 	value_typeof::bigint64_array,
 	value_typeof::biguint64_array,
 	value_typeof::data_view,
@@ -47,18 +47,18 @@ struct visit_vm_property_key {
 		explicit visit_vm_property_key(Visit& visit) : visit_{visit} {}
 
 		template <class Accept>
-		auto operator()(value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
-				auto value = bound_value{lock(), value_of<Tag>::from(subject)};
+				auto value = value_of{lock(), local_of<Tag>::from(subject)};
 				return accept(tag, *this, value);
 			};
-			if (subject.is_string()) {
-				if (value_of<string_tag>::from(subject).is_latin1()) {
+			if (subject->is_string()) {
+				if (local_of<string_tag>::from(subject)->is_latin1()) {
 					return accept_as(string_tag_of<char>{});
 				} else {
 					return accept_as(string_tag_of<char16_t>{});
 				}
-			} else if (subject.is_number()) {
+			} else if (subject->is_number()) {
 				return accept_as(number_tag_of<std::int32_t>{});
 			} else {
 				return accept_as(symbol_tag{});
@@ -75,16 +75,16 @@ template <auto Key>
 struct visit_vm_key_literal {
 		explicit constexpr visit_vm_key_literal(auto* /*transfer*/) {}
 
-		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> value_of<name_tag> {
+		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> local_of<name_tag> {
 			if (!local_key_) {
 				constexpr auto key = util::make_consteval_string_view(Key);
-				local_key_ = transfer_in<value_of<name_tag>>(key, accept_or_visit.lock());
+				local_key_ = transfer_in<local_of<name_tag>>(key, accept_or_visit.lock());
 			}
 			return local_key_;
 		}
 
 	private:
-		value_of<name_tag> local_key_;
+		local_of<name_tag> local_key_;
 };
 
 struct visit_vm_value {
@@ -92,51 +92,51 @@ struct visit_vm_value {
 		explicit visit_vm_value(const runtime_lock& lock) : lock_{lock} {}
 
 		template <class Accept>
-		auto operator()(value_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
 			// TODO: reference map
 			return util::template_traverse(
 				accept_tags_of_v<Accept>,
 				util::overloaded{
 					// Fast paths
 					[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_undefined() ? accept_as(undefined_tag{}, subject, accept) : next();
+						return subject->is_undefined() ? accept_as(undefined_tag{}, subject, accept) : next();
 					},
 					[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_null() ? accept_as(null_tag{}, subject, accept) : next();
+						return subject->is_null() ? accept_as(null_tag{}, subject, accept) : next();
 					},
 					[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_boolean() ? accept_as(boolean_tag{}, subject, accept) : next();
+						return subject->is_boolean() ? accept_as(boolean_tag{}, subject, accept) : next();
 					},
 					[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_number() ? accept_as(number_tag{}, subject, accept) : next();
+						return subject->is_number() ? accept_as(number_tag{}, subject, accept) : next();
 					},
 					[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_string() ? accept_as(string_tag{}, subject, accept) : next();
+						return subject->is_string() ? accept_as(string_tag{}, subject, accept) : next();
 					},
 					[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_bigint() ? accept_as(bigint_tag{}, subject, accept) : next();
+						return subject->is_bigint() ? accept_as(bigint_tag{}, subject, accept) : next();
 					},
 					[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_date() ? accept_as(date_tag{}, subject, accept) : next();
+						return subject->is_date() ? accept_as(date_tag{}, subject, accept) : next();
 					},
 					[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_array() ? accept_as(list_tag{}, subject, accept) : next();
+						return subject->is_array() ? accept_as(list_tag{}, subject, accept) : next();
 					},
 					[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_function() ? accept_as(function_tag{}, subject, accept) : next();
+						return subject->is_function() ? accept_as(function_tag{}, subject, accept) : next();
 					},
 
 					// Unknown tag
 					[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 
 					// Slow path
-					[ & ]() -> accept_target_t<Accept> {
-						auto type = subject.inspect();
-						const auto [... primitive_types ] = primitive_typeofs;
+					[ & ] -> accept_target_t<Accept> {
+						auto type = subject->inspect();
+						constexpr auto [... primitive_types ] = primitive_typeofs;
 						if ((... || (type == primitive_types))) {
-							return inspected(type, value_of<primitive_tag>::from(subject), accept);
+							return inspected(type, local_of<primitive_tag>::from(subject), accept);
 						} else {
-							return inspected(type, value_of<object_tag>::from(subject), accept);
+							return inspected(type, local_of<object_tag>::from(subject), accept);
 						}
 					},
 				}
@@ -144,13 +144,13 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::number: return accept_as(number_tag{}, subject, accept);
 				case value_typeof::number_i32: return accept_as(number_tag_of<std::int32_t>{}, subject, accept);
 				default: std::unreachable();
@@ -158,8 +158,8 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::string: return accept_as(string_tag_of<char16_t>{}, subject, accept);
 				case value_typeof::string_latin1: return accept_as(string_tag_of<char>{}, subject, accept);
 				default: std::unreachable();
@@ -167,8 +167,8 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::bigint: return accept_as(bigint_tag{}, subject, accept);
 				case value_typeof::bigint_i64: return accept_as(bigint_tag_of<std::int64_t>{}, subject, accept);
 				default: std::unreachable();
@@ -176,18 +176,18 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		[[nodiscard]] auto lock() const -> const runtime_lock& { return lock_.get(); }
@@ -195,7 +195,7 @@ struct visit_vm_value {
 
 	private:
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::undefined: return accept_as(undefined_tag{}, subject, accept);
 				case value_typeof::null: return accept_as(null_tag{}, subject, accept);
@@ -212,13 +212,13 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			const auto [... data_block_types ] = data_block_typeofs;
-			const auto [... array_buffer_view_types ] = array_buffer_view_typeofs;
+		constexpr auto inspected(value_typeof type_of, local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			constexpr auto [... data_block_types ] = data_block_typeofs;
+			constexpr auto [... array_buffer_view_types ] = array_buffer_view_typeofs;
 			if ((... || (type_of == data_block_types))) {
-				return inspected(type_of, value_of<data_block_tag>::from(subject), accept);
+				return inspected(type_of, local_of<data_block_tag>::from(subject), accept);
 			} else if ((... || (type_of == array_buffer_view_types))) {
-				return inspected(type_of, value_of<array_buffer_view_tag>::from(subject), accept);
+				return inspected(type_of, local_of<array_buffer_view_tag>::from(subject), accept);
 			} else {
 				switch (type_of) {
 					case value_typeof::external: return accept_as(external_tag{}, subject, accept);
@@ -228,12 +228,12 @@ struct visit_vm_value {
 					case value_typeof::array:
 						{
 							auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_vm_value>, visit_vm_value&>{*this};
-							return accept(list_tag{}, visit_entry, bound_value{lock_, value_of<record_tag>::from(subject)});
+							return accept(list_tag{}, visit_entry, value_of{lock_, local_of<record_tag>::from(subject)});
 						}
 					case value_typeof::dictionary:
 						{
 							auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_vm_value>, visit_vm_value&>{*this};
-							return accept(dictionary_tag{}, visit_entry, bound_value{lock_, value_of<record_tag>::from(subject)});
+							return accept(dictionary_tag{}, visit_entry, value_of{lock_, local_of<record_tag>::from(subject)});
 						}
 					default: std::unreachable();
 				}
@@ -241,7 +241,7 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::array_buffer: return accept_as(array_buffer_tag{}, subject, accept);
 				case value_typeof::shared_array_buffer: return accept_as(shared_array_buffer_tag{}, subject, accept);
@@ -250,7 +250,7 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::bigint64_array: return accept_as(typed_array_tag_of<std::int64_t>{}, subject, accept);
 				case value_typeof::biguint64_array: return accept_as(typed_array_tag_of<std::uint64_t>{}, subject, accept);
@@ -270,25 +270,68 @@ struct visit_vm_value {
 		}
 
 		template <class Accept, class Tag>
-		auto accept_as(Tag tag, value_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(tag, *this, bound_value{lock_, value_of<Tag>::from(subject)});
+		auto accept_as(Tag tag, local_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(tag, *this, value_of{lock_, local_of<Tag>::from(subject)});
 		}
 
 		std::reference_wrapper<const runtime_lock> lock_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Tag>
+struct visit_vm_value_of {
+	private:
+		using visit_type = visit_vm_value;
+
+	public:
+		constexpr explicit visit_vm_value_of(const runtime_lock& lock) : visit_{lock} {}
+
+		template <class Accept>
+		constexpr auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, visit_, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, object_tag>
+		constexpr auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_type>, visit_type&>{visit_};
+			return accept(object_tag{}, visit_entry, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, list_tag>
+		constexpr auto operator()(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_type>, visit_type&>{visit_};
+			return accept(list_tag{}, visit_entry, subject);
+		}
+
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		visit_type visit_;
+};
+
 } // namespace isolated_vm
 
 namespace js {
 using namespace isolated_vm;
 
 template <class Tag>
-struct visit<void, value_of<Tag>> : visit_vm_value {
+struct visit<void, local_of<Tag>> : visit_vm_value {
 		using visit_vm_value::visit_vm_value;
 };
 
+// Pass through `value_of<Tag>`
+template <class Tag>
+struct visit<void, isolated_vm::value_of<Tag>> : isolated_vm::visit_vm_value_of<Tag> {
+		using isolated_vm::visit_vm_value_of<Tag>::visit_vm_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<isolated_vm::value_of<Tag>> : std::type_identity<isolated_vm::local_of<Tag>> {};
+
 template <auto Key>
-struct visit_key_literal<Key, value_of<record_tag>> : visit_vm_key_literal<Key> {
+struct visit_key_literal<Key, local_of<record_tag>> : visit_vm_key_literal<Key> {
 		using visit_vm_key_literal<Key>::visit_vm_key_literal;
 };
 

package/addon/value/array.cc

@@ -1,19 +1,19 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.array;
-import :handle.value_of;
+import :handle.local_of;
 import :value.record;
 import auto_js;
 
 namespace isolated_vm {
 using namespace js;
 
-// value_of<list_tag>
-class EXPORT value_for_array : public value_next<list_tag> {
+// local_of<list_tag>
+class EXPORT local_for_array : public local_next<list_tag> {
 	public:
-		using value_next<list_tag>::value_next;
-		auto set(const runtime_lock& lock, int key, value_of<> value) const -> void;
-		static auto make(const runtime_lock& lock, int capacity = 0) -> value_of<list_tag>;
+		using local_next<list_tag>::local_next;
+		auto set(const runtime_lock& lock, int key, local_of<> value) const -> void;
+		static auto make(const runtime_lock& lock, int capacity = 0) -> local_of<list_tag>;
 };
 
 } // namespace isolated_vm

package/addon/value/array_buffer.cc

@@ -1,7 +1,7 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.array_buffer;
-import :handle.bound_value;
+import :handle.local_of;
 import :handle.value_of;
 import :value.object;
 import auto_js;
@@ -10,43 +10,52 @@ import std;
 namespace isolated_vm {
 using namespace js;
 
-// value_of<data_block_tag>
-class EXPORT value_for_data_block : public value_next<data_block_tag> {
+// local_of<data_block_tag>
+class EXPORT local_for_data_block : public local_next<data_block_tag> {
 	public:
-		using value_next<data_block_tag>::value_next;
+		using local_next<data_block_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-// bound_value<data_block_tag>
-class EXPORT bound_value_for_data_block : public bound_value_next<data_block_tag> {
+// value_of<data_block_tag>
+class EXPORT value_for_data_block : public value_next<data_block_tag> {
 	public:
-		using bound_value_next<data_block_tag>::bound_value_next;
+		using value_next<data_block_tag>::value_next;
 		[[nodiscard]] auto byte_length() const -> std::size_t;
 		[[nodiscard]] auto data() const -> std::byte*;
 		explicit operator js::array_buffer() const;
 		explicit operator std::span<std::byte>() const;
 };
 
-// value_of<array_buffer_tag>
-class EXPORT value_for_array_buffer : public value_next<array_buffer_tag> {
+// local_of<array_buffer_tag>
+class EXPORT local_for_array_buffer : public local_next<array_buffer_tag> {
 	public:
-		using value_next<array_buffer_tag>::value_next;
-		static auto make(const runtime_lock& lock, js::array_buffer buffer) -> value_of<array_buffer_tag>;
+		using local_next<array_buffer_tag>::local_next;
+		static auto make(const runtime_lock& lock, js::array_buffer buffer) -> local_of<array_buffer_tag>;
 };
 
-// value_of<array_buffer_view_tag>
-class EXPORT value_for_array_buffer_view : public value_next<array_buffer_view_tag> {
+// local_of<array_buffer_view_tag>
+class EXPORT local_for_array_buffer_view : public local_next<array_buffer_view_tag> {
 	public:
-		using value_next<array_buffer_view_tag>::value_next;
+		using local_next<array_buffer_view_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-// bound_value<typed_array_tag_of<Type>>
+// value_of<typed_array_tag_of<Type>>
 template <class Type>
-class EXPORT bound_value_for_typed_array_of : public bound_value_next<typed_array_tag_of<Type>> {
+class EXPORT value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
+	public:
+		using value_next<typed_array_tag_of<Type>>::value_next;
+		[[nodiscard]] auto buffer() const -> local_of<data_block_tag>;
+		[[nodiscard]] auto byte_offset() const -> std::size_t;
+		[[nodiscard]] auto size() const -> std::size_t;
+};
+
+// value_of<data_view_tag>
+class EXPORT value_for_data_view : public value_next<data_view_tag> {
 	public:
-		using bound_value_next<typed_array_tag_of<Type>>::bound_value_next;
-		[[nodiscard]] auto buffer() const -> value_of<data_block_tag>;
+		using value_next<data_view_tag>::value_next;
+		[[nodiscard]] auto buffer() const -> local_of<data_block_tag>;
 		[[nodiscard]] auto byte_offset() const -> std::size_t;
 		[[nodiscard]] auto size() const -> std::size_t;
 };

package/addon/value/function.cc

@@ -6,17 +6,17 @@ namespace isolated_vm {
 using namespace js;
 
 template <class Result>
-auto value_for_function::apply(const runtime_lock& lock, auto&& args) -> Result {
-	using args_type = std::vector<value_of<>>;
-	auto undefined = js::transfer_in_strict<value_of<>>(std::monostate{}, lock);
+auto local_for_function::apply(const runtime_lock& lock, auto&& args) -> Result {
+	using args_type = std::vector<local_of<>>;
+	auto undefined = js::transfer_in_strict<local_of<>>(std::monostate{}, lock);
 	auto argv = js::transfer_in_strict<args_type>(std::forward<decltype(args)>(args), lock);
 	auto result = invoke(lock, undefined, argv);
 	return js::transfer_out<Result>(result, lock);
 }
 
 template <class Result>
-auto value_for_function::call(const runtime_lock& lock, auto&&... args) -> Result {
-	using args_type = std::array<value_of<>, sizeof...(args) + 1>;
+auto local_for_function::call(const runtime_lock& lock, auto&&... args) -> Result {
+	using args_type = std::array<local_of<>, sizeof...(args) + 1>;
 	auto argv = js::transfer_in_strict<args_type>(
 		std::tuple_cat(
 			std::tuple{std::monostate{}},

package/addon/value/function.h.cc

@@ -1,17 +1,17 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.function;
-import :handle.value_of;
+import :handle.local_of;
 import :support.lock_fwd;
 import :value.primitive;
 
 namespace isolated_vm {
 using namespace js;
 
-// value_of<function_tag>
-class EXPORT value_for_function : public value_next<function_tag> {
+// local_of<function_tag>
+class EXPORT local_for_function : public local_next<function_tag> {
 	public:
-		using value_next<function_tag>::value_next;
+		using local_next<function_tag>::local_next;
 
 		template <class Result = std::monostate>
 		auto apply(const runtime_lock& lock, auto&& args) -> Result;
@@ -20,7 +20,7 @@ class EXPORT value_for_function : public value_next<function_tag> {
 		auto call(const runtime_lock& lock, auto&&... args) -> Result;
 
 	private:
-		auto invoke(const runtime_lock& lock, value_of<> that, std::span<value_of<>> argv) -> value_of<>;
+		auto invoke(const runtime_lock& lock, local_of<> that, std::span<local_of<>> argv) -> local_of<>;
 };
 
 } // namespace isolated_vm

package/addon/value/object.cc

@@ -6,10 +6,10 @@ import :value.primitive;
 namespace isolated_vm {
 using namespace js;
 
-// value_of<object_tag>
-class EXPORT value_for_object : public value_next<object_tag> {
+// local_of<object_tag>
+class EXPORT local_for_object : public local_next<object_tag> {
 	public:
-		using value_next<object_tag>::value_next;
+		using local_next<object_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 

package/addon/value/primitive.cc

@@ -1,7 +1,7 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.primitive;
-import :handle.bound_value;
+import :handle.local_of;
 import :handle.value_of;
 import auto_js;
 import std;
@@ -50,9 +50,9 @@ export enum class value_typeof : std::uint8_t {
 };
 
 // value & primitive
-class EXPORT value_for_value : public value_next<value_tag> {
+class EXPORT local_for_value : public local_next<value_tag> {
 	public:
-		using value_next<value_tag>::value_next;
+		using local_next<value_tag>::local_next;
 		[[nodiscard]] auto is_array() const -> bool;
 		[[nodiscard]] auto is_bigint() const -> bool;
 		[[nodiscard]] auto is_boolean() const -> bool;
@@ -65,90 +65,90 @@ class EXPORT value_for_value : public value_next<value_tag> {
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-class EXPORT value_for_primitive : public value_next<primitive_tag> {
+class EXPORT local_for_primitive : public local_next<primitive_tag> {
 	public:
-		using value_next<primitive_tag>::value_next;
+		using local_next<primitive_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
 // null & undefined
-class EXPORT value_for_undefined : public value_next<undefined_tag> {
+class EXPORT local_for_undefined : public local_next<undefined_tag> {
 	public:
-		using value_next<undefined_tag>::value_next;
-		static auto make(const basic_lock& lock) -> value_of<undefined_tag>;
+		using local_next<undefined_tag>::local_next;
+		static auto make(const basic_lock& lock) -> local_of<undefined_tag>;
 };
 
-class EXPORT value_for_null : public value_next<null_tag> {
+class EXPORT local_for_null : public local_next<null_tag> {
 	public:
-		using value_next<null_tag>::value_next;
-		static auto make(const basic_lock& lock) -> value_of<null_tag>;
+		using local_next<null_tag>::local_next;
+		static auto make(const basic_lock& lock) -> local_of<null_tag>;
 };
 
 // boolean
-class EXPORT value_for_boolean : public value_next<boolean_tag> {
+class EXPORT local_for_boolean : public local_next<boolean_tag> {
 	public:
-		using value_next<boolean_tag>::value_next;
-		static auto make(const basic_lock& lock, bool value) -> value_of<boolean_tag>;
+		using local_next<boolean_tag>::local_next;
+		static auto make(const basic_lock& lock, bool value) -> local_of<boolean_tag>;
 };
 
-class EXPORT bound_value_for_boolean : public bound_value_next<boolean_tag> {
+class EXPORT value_for_boolean : public value_next<boolean_tag> {
 	public:
-		using bound_value_next<boolean_tag>::bound_value_next;
+		using value_next<boolean_tag>::value_next;
 		[[nodiscard]] explicit operator bool() const;
 };
 
 // number
-class EXPORT value_for_number : public value_next<number_tag> {
+class EXPORT local_for_number : public local_next<number_tag> {
 	public:
-		using value_next<number_tag>::value_next;
+		using local_next<number_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
-		static auto make(const basic_lock& lock, double value) -> value_of<number_tag_of<double>>;
-		static auto make(const basic_lock& lock, std::int32_t value) -> value_of<number_tag_of<std::int32_t>>;
+		static auto make(const basic_lock& lock, double value) -> local_of<number_tag_of<double>>;
+		static auto make(const basic_lock& lock, std::int32_t value) -> local_of<number_tag_of<std::int32_t>>;
 };
 
-class EXPORT bound_value_for_number : public bound_value_next<number_tag> {
+class EXPORT value_for_number : public value_next<number_tag> {
 	public:
-		using bound_value_next<number_tag>::bound_value_next;
+		using value_next<number_tag>::value_next;
 		[[nodiscard]] explicit operator double() const;
 		[[nodiscard]] explicit operator std::int32_t() const;
 };
 
 // name
-class EXPORT value_for_name : public value_next<name_tag> {
+class EXPORT local_for_name : public local_next<name_tag> {
 	public:
-		using value_next<name_tag>::value_next;
+		using local_next<name_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
 // string
-class EXPORT value_for_string : public value_next<string_tag> {
+class EXPORT local_for_string : public local_next<string_tag> {
 	public:
-		using value_next<string_tag>::value_next;
+		using local_next<string_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 		[[nodiscard]] auto is_latin1() const -> bool;
-		static auto make(const basic_lock& lock, std::u16string_view value) -> value_of<string_tag_of<char16_t>>;
-		static auto make(const basic_lock& lock, std::string_view value) -> value_of<string_tag_of<char>>;
+		static auto make(const basic_lock& lock, std::u16string_view value) -> local_of<string_tag_of<char16_t>>;
+		static auto make(const basic_lock& lock, std::string_view value) -> local_of<string_tag_of<char>>;
 };
 
-class EXPORT bound_value_for_string : public bound_value_next<string_tag> {
+class EXPORT value_for_string : public value_next<string_tag> {
 	public:
-		using bound_value_next<string_tag>::bound_value_next;
+		using value_next<string_tag>::value_next;
 		[[nodiscard]] explicit operator std::string() const;
 		[[nodiscard]] explicit operator std::u16string() const;
 };
 
 // bigint
-class EXPORT value_for_bigint : public value_next<bigint_tag> {
+class EXPORT local_for_bigint : public local_next<bigint_tag> {
 	public:
-		using value_next<bigint_tag>::value_next;
+		using local_next<bigint_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
-		static auto make(const runtime_lock& lock, js::bigint value) -> value_of<bigint_tag_of<js::bigint>>;
-		static auto make(const basic_lock& lock, std::int64_t value) -> value_of<bigint_tag_of<std::int64_t>>;
+		static auto make(const runtime_lock& lock, js::bigint value) -> local_of<bigint_tag_of<js::bigint>>;
+		static auto make(const basic_lock& lock, std::int64_t value) -> local_of<bigint_tag_of<std::int64_t>>;
 };
 
-class EXPORT bound_value_for_bigint : public bound_value_next<bigint_tag> {
+class EXPORT value_for_bigint : public value_next<bigint_tag> {
 	public:
-		using bound_value_next<bigint_tag>::bound_value_next;
+		using value_next<bigint_tag>::value_next;
 		[[nodiscard]] explicit operator js::bigint() const;
 		[[nodiscard]] explicit operator std::int64_t() const;
 };