@auto_js/napi 0.0.8 → 0.0.9

package/transfer/visit.cc

@@ -24,7 +24,7 @@ struct visit_property_name {
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
 			return visit_.get().lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
-					auto value = bound_value{napi_env{visit_.get()}, value_of<Tag>::from(subject)};
+					auto value = value_of{napi_env{visit_.get()}, local_of<Tag>::from(subject)};
 					return accept(tag, *this, value);
 				};
 				switch (napi::invoke(napi_typeof, napi_env{visit_.get()}, subject)) {
@@ -50,17 +50,17 @@ struct visit_napi_key_literal {
 
 		auto operator()(const auto& /*could_be_literally_anything*/, const auto& accept_or_visit) -> napi_value {
 			const auto make = util::overloaded{
-				[](auto& env, std::string_view subject) -> napi::value_of<string_tag_of<char>> {
+				[](auto& env, std::string_view subject) -> napi::local_of<string_tag_of<char>> {
 					auto* value = napi::invoke(node_api_create_property_key_latin1, napi_env{env}, subject.data(), subject.length());
-					return napi::value_of<string_tag_of<char>>::from(value);
+					return napi::local_of<string_tag_of<char>>::from(value);
 				},
-				[](auto& env, std::u16string_view subject) -> napi::value_of<string_tag_of<char16_t>> {
+				[](auto& env, std::u16string_view subject) -> napi::local_of<string_tag_of<char16_t>> {
 					auto* value = napi::invoke(node_api_create_property_key_utf16, napi_env{env}, subject.data(), subject.length());
-					return napi::value_of<string_tag_of<char16_t>>::from(value);
+					return napi::local_of<string_tag_of<char16_t>>::from(value);
 				},
-				[](auto& env, std::u8string_view subject) -> napi::value_of<string_tag_of<char8_t>> {
+				[](auto& env, std::u8string_view subject) -> napi::local_of<string_tag_of<char8_t>> {
 					auto* value = napi::invoke(node_api_create_property_key_utf8, napi_env{env}, reinterpret_cast<const char*>(subject.data()), subject.length());
-					return napi::value_of<string_tag_of<char8_t>>::from(value);
+					return napi::local_of<string_tag_of<char8_t>>::from(value);
 				},
 			};
 			if (local_key_ == napi_value{}) {
@@ -109,7 +109,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// If the private `immediate` operation is defined: this public operation will first
 		// perform a reference map lookup, then delegate to the private operation if not found.
 		template <class Tag, class Accept>
-		auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
+		auto operator()(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
 			requires requires { immediate(subject, accept); } {
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				return immediate(subject, accept);
@@ -118,31 +118,31 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 		// Visit operations for non-refable types.
 		template <class Accept>
-		auto operator()(value_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (maybe_is_number_int32(subject).value_or(false)) {
-				return immediate(value_of<number_tag_of<std::int32_t>>::from(subject), accept);
+				return immediate(local_of<number_tag_of<std::int32_t>>::from(subject), accept);
 			} else {
-				return immediate(value_of<number_tag_of<double>>::from(subject), accept);
+				return immediate(local_of<number_tag_of<double>>::from(subject), accept);
 			}
 		}
 
 		template <class Accept, class Type>
-		auto operator()(value_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
@@ -158,25 +158,25 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 						auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
 						switch (type_of) {
 							case napi_undefined:
-								return (*this)(value_of<undefined_tag>::from(subject), accept);
+								return (*this)(local_of<undefined_tag>::from(subject), accept);
 							case napi_null:
-								return (*this)(value_of<null_tag>::from(subject), accept);
+								return (*this)(local_of<null_tag>::from(subject), accept);
 							case napi_boolean:
-								return (*this)(value_of<boolean_tag>::from(subject), accept);
+								return (*this)(local_of<boolean_tag>::from(subject), accept);
 							case napi_number:
-								return (*this)(value_of<number_tag>::from(subject), accept);
+								return (*this)(local_of<number_tag>::from(subject), accept);
 							case napi_string:
-								return immediate(value_of<string_tag>::from(subject), accept);
+								return immediate(local_of<string_tag>::from(subject), accept);
 							case napi_symbol:
-								return immediate(value_of<symbol_tag>::from(subject), accept);
+								return immediate(local_of<symbol_tag>::from(subject), accept);
 							case napi_object:
-								return immediate(value_of<object_tag>::from(subject), accept);
+								return immediate(local_of<object_tag>::from(subject), accept);
 							case napi_function:
-								return immediate(value_of<function_tag>::from(subject), accept);
+								return immediate(local_of<function_tag>::from(subject), accept);
 							case napi_external:
-								return immediate(value_of<external_tag>::from(subject), accept);
+								return immediate(local_of<external_tag>::from(subject), accept);
 							case napi_bigint:
-								return immediate(value_of<bigint_tag>::from(subject), accept);
+								return immediate(local_of<bigint_tag>::from(subject), accept);
 						}
 						std::unreachable();
 					},
@@ -187,16 +187,16 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				// Universal fast checks
 				auto fast_path = util::overloaded{
 					[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_undefined(napi_env{*this}, subject) ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
+						return fast_is_undefined(napi_env{*this}, subject) ? (*this)(local_of<undefined_tag>::from(subject), accept) : next();
 					},
 					[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_null(napi_env{*this}, subject) ? (*this)(value_of<null_tag>::from(subject), accept) : next();
+						return fast_is_null(napi_env{*this}, subject) ? (*this)(local_of<null_tag>::from(subject), accept) : next();
 					},
 					[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
 						if (fast_is_false(napi_env{*this}, subject)) {
-							return (*this)(value_of<false_tag>::from(subject), accept);
+							return (*this)(local_of<false_tag>::from(subject), accept);
 						} else if (fast_is_true(napi_env{*this}, subject)) {
-							return (*this)(value_of<true_tag>::from(subject), accept);
+							return (*this)(local_of<true_tag>::from(subject), accept);
 						} else {
 							return next();
 						}
@@ -206,27 +206,27 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				// Extended fast checks
 				auto extended_fast_path = util::overloaded{
 					[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_number(subject) ? (*this)(value_of<number_tag>::from(subject), accept) : next();
+						return fast_is_number(subject) ? (*this)(local_of<number_tag>::from(subject), accept) : next();
 					},
 					[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_string(subject) ? immediate(value_of<string_tag>::from(subject), accept) : next();
+						return fast_is_string(subject) ? immediate(local_of<string_tag>::from(subject), accept) : next();
 					},
 					[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_bigint(subject) ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
+						return fast_is_bigint(subject) ? immediate(local_of<bigint_tag>::from(subject), accept) : next();
 					},
 					[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(value_of<date_tag>::from(subject), accept) : next();
+						return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(local_of<date_tag>::from(subject), accept) : next();
 					},
 					[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_array(subject) ? immediate(value_of<list_tag>::from(subject), accept) : next();
+						return fast_is_array(subject) ? immediate(local_of<list_tag>::from(subject), accept) : next();
 					},
 					[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
 						// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
 						// checks. We don't really want to accept those types here, I don't think..
-						return fast_is_object(subject) ? immediate(value_of<object_tag>::from(subject), accept) : next();
+						return fast_is_object(subject) ? immediate(local_of<object_tag>::from(subject), accept) : next();
 					},
 					[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return fast_is_function(subject) ? immediate(value_of<function_tag>::from(subject), accept) : next();
+						return fast_is_function(subject) ? immediate(local_of<function_tag>::from(subject), accept) : next();
 					},
 
 					// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
@@ -246,7 +246,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				return util::template_traverse(
 					accept_tags_of_v<Accept>,
@@ -274,79 +274,79 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// I think this only applies to `symbol_tag`
 		template <class Accept, class Tag>
 			requires std::is_convertible_v<Tag, primitive_tag>
-		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// strings
 		template <class Accept>
-		auto immediate(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (maybe_is_string_latin1(subject).value_or(false)) {
-				return accept_tagged(value_of<string_tag_of<char>>::from(subject), accept);
+				return accept_tagged(local_of<string_tag_of<char>>::from(subject), accept);
 			} else {
-				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
+				return accept_tagged(local_of<string_tag_of<char16_t>>::from(subject), accept);
 			}
 		}
 
 		// bigint
 		template <class Accept>
-		auto immediate(value_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(value_of<bigint_tag_of<bigint>>::from(subject), accept);
+		auto immediate(local_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(local_of<bigint_tag_of<bigint>>::from(subject), accept);
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (napi::invoke(napi_is_array, napi_env{*this}, subject)) {
-				return immediate(value_of<list_tag>::from(subject), accept);
+				return immediate(local_of<list_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
-				return immediate(value_of<date_tag>::from(subject), accept);
+				return immediate(local_of<date_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_typedarray, napi_env{*this}, subject)) {
-				return immediate(value_of<typed_array_tag>::from(subject), accept);
+				return immediate(local_of<typed_array_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
-				return immediate(value_of<data_view_tag>::from(subject), accept);
+				return immediate(local_of<data_view_tag>::from(subject), accept);
 			} else if (maybe_is_shared_array_buffer(env_.get(), subject).value_or(false)) {
-				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
 			} else if (is_object_array_buffer(env_.get(), subject)) {
-				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<array_buffer_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
-				return immediate(value_of<promise_tag>::from(subject), accept);
+				return immediate(local_of<promise_tag>::from(subject), accept);
 			} else {
-				return immediate(value_of<dictionary_tag>::from(subject), accept);
+				return immediate(local_of<dictionary_tag>::from(subject), accept);
 			}
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(value_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// data blocks
 		template <class Accept>
-		auto immediate(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (is_data_block_array_buffer(env_.get(), subject)) {
-				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<array_buffer_tag>::from(subject), accept);
 			} else {
-				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
 			}
 		}
 
 		template <class Accept, class Tag>
 			requires std::is_convertible_v<Tag, data_block_tag>
-		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// array buffer views
 		template <class Accept>
-		auto immediate(value_of<typed_array_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto bound_subject_variant = bound_value_for_typed_array::make_bound(environment(), subject);
+		auto immediate(local_of<typed_array_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto bound_subject_variant = value_for_typed_array::make_bound(environment(), subject);
 			if (bound_subject_variant.index() == std::variant_npos) {
 				std::unreachable();
 			} else {
 				return std::visit(
-					[ & ]<class Tag>(bound_value<Tag> value) -> accept_target_t<Accept> {
+					[ & ]<class Tag>(value_of<Tag> value) -> accept_target_t<Accept> {
 						return accept(Tag{}, *this, value);
 					},
 					bound_subject_variant
@@ -355,53 +355,87 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class Accept>
-		auto immediate(value_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// externals
 		template <class Accept>
-		auto immediate(value_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// promise
 		template <class Accept>
-		auto immediate(value_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// function
 		template <class Accept>
-		auto immediate(value_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// array
 		template <class Accept>
-		auto immediate(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto target = napi::bound_value{napi_env{*this}, value_of<list_tag>::from(subject)};
+		auto immediate(local_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{napi_env{*this}, local_of<list_tag>::from(subject)};
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
 			return accept(list_tag{}, visit_entry, target);
 		}
 
 		// object / record
 		template <class Accept>
-		auto immediate(value_of<dictionary_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto target = napi::bound_value{napi_env{*this}, value_of<dictionary_tag>::from(subject)};
+		auto immediate(local_of<dictionary_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{napi_env{*this}, local_of<dictionary_tag>::from(subject)};
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
 			return accept(dictionary_tag{}, visit_entry, target);
 		}
 
-		// Convenience function which wraps in `napi::bound_value` and invokes `accept`.
+		// Convenience function which wraps in `napi::value_of` and invokes `accept`.
 		template <class Tag, class Accept>
-		[[nodiscard]] auto accept_tagged(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(Tag{}, *this, napi::bound_value{environment(), subject});
+		[[nodiscard]] auto accept_tagged(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, *this, napi::value_of{environment(), subject});
 		}
 
 		std::reference_wrapper<Environment> env_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Meta, class Tag>
+struct visit_napi_value_of {
+	private:
+		using visit_type = visit_value_with<Meta>;
+
+	public:
+		constexpr explicit visit_napi_value_of(auto* transfer, auto& environment) : visit_{transfer, environment} {}
+
+		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_property_name<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_property_name<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 js::napi
 
 namespace js {
@@ -413,10 +447,19 @@ struct visit<Meta, napi_value> : napi::visit_value_with<Meta> {
 };
 
 template <class Meta, class Tag>
-struct visit<Meta, napi::value_of<Tag>> : napi::visit_value_with<Meta> {
+struct visit<Meta, napi::local_of<Tag>> : napi::visit_value_with<Meta> {
 		using napi::visit_value_with<Meta>::visit_value_with;
 };
 
+// Pass through `value_of<Tag>`
+template <class Meta, class Tag>
+struct visit<Meta, napi::value_of<Tag>> : napi::visit_napi_value_of<Meta, Tag> {
+		using napi::visit_napi_value_of<Meta, Tag>::visit_napi_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<napi::value_of<Tag>> : std::type_identity<napi_value> {};
+
 // Object key maker via napi
 template <auto Key>
 struct visit_key_literal<Key, napi_value> : napi::visit_napi_key_literal<Key> {

package/value/array.cc

@@ -1,29 +1,27 @@
 module napi_js;
-import :api;
-import :bound_value;
 
 namespace js::napi {
 
-auto bound_value_for_vector::begin() const -> iterator {
+auto value_for_vector::begin() const -> iterator {
 	return {*this, 0};
 }
 
-auto bound_value_for_vector::end() const -> iterator {
+auto value_for_vector::end() const -> iterator {
 	return {*this, size()};
 }
 
-auto bound_value_for_vector::size() const -> std::uint32_t {
+auto value_for_vector::size() const -> std::uint32_t {
 	if (size_ == 0) {
 		size_ = napi::invoke(napi_get_array_length, env(), napi_value{*this}) + 1;
 	}
 	return size_ - 1;
 }
 
-bound_value_for_vector::iterator::iterator(bound_value_for_vector subject, size_type index) :
+value_for_vector::iterator::iterator(value_for_vector subject, size_type index) :
 		subject_{subject},
 		index_{index} {}
 
-auto bound_value_for_vector::iterator::operator*() const -> value_type {
+auto value_for_vector::iterator::operator*() const -> value_type {
 	return value_type::from(napi::invoke(napi_get_element, subject_.env(), napi_value{subject_}, index_));
 }
 

package/value/array.h.cc

@@ -5,11 +5,11 @@ import util;
 
 namespace js::napi {
 
-class bound_value_for_vector : public bound_value_next<vector_tag> {
+class value_for_vector : public value_next<vector_tag> {
 	public:
 		class iterator;
-		using bound_value_next<vector_tag>::bound_value_next;
-		using value_type = value_of<value_tag>;
+		using value_next<vector_tag>::value_next;
+		using value_type = local_of<value_tag>;
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
@@ -19,15 +19,15 @@ class bound_value_for_vector : public bound_value_next<vector_tag> {
 		mutable std::uint32_t size_{};
 };
 
-class bound_value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
+class value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
 	public:
 		using arithmetic_facade::operator+;
 		using difference_type = arithmetic_facade::difference_type;
 		using size_type = std::uint32_t;
-		using value_type = bound_value_for_vector::value_type;
+		using value_type = value_for_vector::value_type;
 
 		iterator() = default;
-		iterator(bound_value_for_vector subject, size_type index);
+		iterator(value_for_vector subject, size_type index);
 
 		auto operator*() const -> value_type;
 
@@ -42,7 +42,7 @@ class bound_value_for_vector::iterator : public util::random_access_iterator_fac
 	private:
 		auto operator+() const -> size_type { return index_; }
 
-		bound_value_for_vector subject_;
+		value_for_vector subject_;
 		size_type index_{};
 };
 

package/value/array_buffer.cc

@@ -1,14 +1,11 @@
 module napi_js;
-import :api;
-import :array_buffer;
-import :support.host;
 import std;
 import v8;
 
 namespace js::napi {
 
-// `bound_value_for_data_block`
-bound_value_for_data_block::operator std::span<std::byte>() const {
+// `value_for_data_block`
+value_for_data_block::operator std::span<std::byte>() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	void* bytes;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -17,25 +14,25 @@ bound_value_for_data_block::operator std::span<std::byte>() const {
 	return std::span{reinterpret_cast<std::byte*>(bytes), byte_length};
 }
 
-// `bound_value_for_array_buffer`
-bound_value_for_array_buffer::operator js::array_buffer() const {
+// `value_for_array_buffer`
+value_for_array_buffer::operator js::array_buffer() const {
 	return js::array_buffer{std::span<std::byte>{*this}};
 }
 
-// `bound_value_for_shared_array_buffer`
-bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
-	auto byte_length = shared_array_buffer_get_byte_length(value_of{*this});
-	auto backing_store = shared_array_buffer_get_backing_store(value_of{*this});
+// `value_for_shared_array_buffer`
+value_for_shared_array_buffer::operator js::shared_array_buffer() const {
+	auto byte_length = shared_array_buffer_get_byte_length(local_of{*this});
+	auto backing_store = shared_array_buffer_get_backing_store(local_of{*this});
 	return js::shared_array_buffer{byte_length, std::move(backing_store)};
 }
 
-// `value_for_typed_array`
-auto value_for_typed_array::make(const environment& env, napi_typedarray_type type_tag, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag> {
-	return value_of<typed_array_tag>::from(napi::invoke(napi_create_typedarray, napi_env{env}, type_tag, length, napi_value{buffer}, byte_offset));
+// `local_for_typed_array`
+auto local_for_typed_array::make(const environment& env, napi_typedarray_type type_tag, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag> {
+	return local_of<typed_array_tag>::from(napi::invoke(napi_create_typedarray, napi_env{env}, type_tag, length, napi_value{buffer}, byte_offset));
 }
 
-// `bound_value_for_typed_array`
-auto bound_value_for_typed_array::make_bound(const environment& env, value_of<typed_array_tag> typed_array) -> any_bound_typed_array {
+// `value_for_typed_array`
+auto value_for_typed_array::make_bound(const environment& env, local_of<typed_array_tag> typed_array) -> any_value_typed_array {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	napi_typedarray_type type_tag;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -45,8 +42,8 @@ auto bound_value_for_typed_array::make_bound(const environment& env, value_of<ty
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	std::size_t byte_offset;
 	napi::invoke0(napi_get_typedarray_info, env, napi_value{typed_array}, &type_tag, &length, nullptr, &array_buffer, &byte_offset);
-	const auto make = [ & ]<class Tag>(Tag /*tag*/) -> any_bound_typed_array {
-		return bound_value<Tag>{env, value_of<Tag>::from(typed_array), std::tuple{value_of<data_block_tag>::from(array_buffer), byte_offset, length}};
+	const auto make = [ & ]<class Tag>(Tag /*tag*/) -> any_value_typed_array {
+		return value_of<Tag>{env, local_of<Tag>::from(typed_array), std::tuple{local_of<data_block_tag>::from(array_buffer), byte_offset, length}};
 	};
 	switch (type_tag) {
 		case napi_bigint64_array: return make(typed_array_tag_of<std::int64_t>{});
@@ -65,26 +62,26 @@ auto bound_value_for_typed_array::make_bound(const environment& env, value_of<ty
 	std::unreachable();
 }
 
-// `value_for_data_view`
-auto value_for_data_view::make(const environment& env, value_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
+// `local_for_data_view`
+auto local_for_data_view::make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
 	if (napi::invoke(napi_is_arraybuffer, napi_env{env}, buffer)) {
-		return make(env, value_of<array_buffer_tag>::from(buffer), byte_offset, length);
+		return make(env, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
 	} else {
-		return make(env, value_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
+		return make(env, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
 	}
 }
 
-auto value_for_data_view::make(const environment& env, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
-	return value_of<data_view_tag>::from(napi::invoke(napi_create_dataview, napi_env{env}, length, napi_value{buffer}, byte_offset));
+auto local_for_data_view::make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
+	return local_of<data_view_tag>::from(napi::invoke(napi_create_dataview, napi_env{env}, length, napi_value{buffer}, byte_offset));
 }
 
-auto value_for_data_view::make(const environment& /*env*/, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
+auto local_for_data_view::make(const environment& /*env*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
 	return make_sab_data_view(buffer, byte_offset, length);
 }
 
-// `bound_value_for_data_view`
-bound_value_for_data_view::bound_value_for_data_view(napi_env env, value_of<data_view_tag> data_view) :
-		bound_value_next{
+// `value_for_data_view`
+value_for_data_view::value_for_data_view(napi_env env, local_of<data_view_tag> data_view) :
+		value_next{
 			env,
 			data_view,
 			[ & ] -> auto {
@@ -95,7 +92,7 @@ bound_value_for_data_view::bound_value_for_data_view(napi_env env, value_of<data
 				// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 				std::size_t byte_offset;
 				napi::invoke0(napi_get_dataview_info, env, napi_value{data_view}, &length, nullptr, &array_buffer, &byte_offset);
-				return std::tuple{value_of<data_block_tag>::from(array_buffer), byte_offset, length};
+				return std::tuple{local_of<data_block_tag>::from(array_buffer), byte_offset, length};
 			}(),
 		} {}