@auto_js/napi 0.0.1 → 0.0.2

package/transfer/visit.cc

@@ -1,19 +1,14 @@
-module;
-#include <functional>
-#include <utility>
 export module napi_js:visit;
-import :api;
 import :container;
-import :environment_fwd;
-import :utility;
 import :value;
+import std;
 import util;
+import v8;
 
-namespace js {
-using namespace napi;
+namespace js::napi {
 
 // Instantiated in the acceptor that corresponds to a napi visitor
-struct napi_reference_map_type {
+struct reference_map_type {
 		template <class Type>
 		using type = napi::value_map<Type>;
 };
@@ -21,24 +16,22 @@ struct napi_reference_map_type {
 // Visitor which may visit only property names. `symbol` should probably be rethought since they are
 // not cloneable.
 template <class Visit>
-struct visit_napi_property_name {
+struct visit_property_name {
 	public:
-		explicit visit_napi_property_name(Visit& visit) : visit_{visit} {}
+		explicit visit_property_name(Visit& visit) : visit_{visit} {}
 
 		template <class Accept>
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
-			return visit_.get().lookup_or_visit(accept, subject, [ & ]() -> 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)};
+					return accept(tag, *this, value);
+				};
 				switch (napi::invoke(napi_typeof, napi_env{visit_.get()}, subject)) {
-					case napi_number:
-						return visit_(napi::value<number_tag>::from(subject), accept);
-					case napi_string:
-						// TODO: This looks up in the reference map twice. This should actually use
-						// `make_property_name`.
-						return visit_(napi::value<string_tag>::from(subject), accept);
-					case napi_symbol:
-						return visit_(napi::value<symbol_tag>::from(subject), accept);
-					default:
-						std::unreachable();
+					case napi_number: return accept_as(number_tag_of<std::int32_t>{});
+					case napi_string: return accept_as(string_tag_of<char16_t>{});
+					case napi_symbol: return accept_as(symbol_tag{});
+					default: std::unreachable();
 				}
 			});
 		}
@@ -49,220 +42,296 @@ struct visit_napi_property_name {
 		std::reference_wrapper<Visit> visit_;
 };
 
+// `visit_key_literal` instantiation which creates property keys
+template <auto Key>
+struct visit_napi_key_literal {
+	public:
+		explicit constexpr visit_napi_key_literal(auto* /*transfer*/) {}
+
+		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* 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);
+				},
+				[](auto& env, std::u16string_view subject) -> napi::value_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);
+				},
+				[](auto& env, std::u8string_view subject) -> napi::value_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);
+				},
+			};
+			if (local_key_ == napi_value{}) {
+				constexpr auto key = util::make_consteval_string_view(Key);
+				auto& environment = accept_or_visit.environment();
+				auto storage = environment.string_table_storage(Key);
+				if (storage) {
+					auto& reference = *storage;
+					if (reference) {
+						local_key_ = reference.get(environment);
+					} else {
+						auto value = make(environment, key);
+						reference.reset(environment, value);
+						local_key_ = napi_value{value};
+					}
+				} else {
+					return make(environment, key);
+				}
+			}
+			return local_key_;
+		}
+
+	private:
+		napi_value local_key_{};
+};
+
 // Base napi visitor implementing all functionality. Napi doesn't give us granular information like
 // "is this a latin1 string" and all checks must be made at once. So it's structured it great deal
 // differently than the v8 visitor.
-template <auto_environment Environment, class Target>
-struct visit_napi_value;
+template <auto_environment Environment, class Ref>
+struct visit_value;
 
 template <class Meta>
-using visit_napi_value_with = visit_napi_value<
+using visit_value_with = visit_value<
 	typename Meta::visit_context_type,
 	typename Meta::accept_reference_type>;
 
-template <auto_environment Environment, class Target>
-struct visit_napi_value
-		: napi::environment_scope<Environment>,
-			reference_map_t<Target, napi_reference_map_type> {
+template <auto_environment Environment, class Reference>
+struct visit_value : reference_map_t<Reference, reference_map_type> {
 	public:
-		using reference_map_t<Target, napi_reference_map_type>::lookup_or_visit;
+		using reference_map_t<Reference, reference_map_type>::lookup_or_visit;
 
-		visit_napi_value(auto* /*transfer*/, Environment& env) :
-				napi::environment_scope<Environment>{env},
-				reference_map_t<Target, napi_reference_map_type>{env},
-				equal_{env} {}
+		visit_value(auto* /*transfer*/, Environment& env) :
+				reference_map_t<Reference, reference_map_type>{env},
+				env_{env} {}
 
 		// 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 <auto_tag Tag, class Accept>
-		auto operator()(value<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
+		template <class Tag, class Accept>
+		auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
 			requires requires { immediate(subject, accept); } {
-			return lookup_or_visit(accept, subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				return immediate(subject, accept);
 			});
 		}
 
 		// Visit operations for non-refable types.
 		template <class Accept>
-		auto operator()(value<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			null_ = subject;
-			return accept_tagged(subject, accept);
+		auto operator()(value_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			undefined_ = subject;
-			return accept_tagged(subject, accept);
+		auto operator()(value_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto operator()(value_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(napi::value<number_tag_of<double>>::from(subject), accept);
+		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (std::bit_cast<v8::Local<v8::Number>>(subject)->IsInt32()) {
+				return immediate(value_of<number_tag_of<std::int32_t>>::from(subject), accept);
+			} else {
+				return immediate(value_of<number_tag_of<double>>::from(subject), accept);
+			}
 		}
 
-		template <class Accept>
-		auto operator()(value<symbol_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		template <class Accept, class Type>
+		auto operator()(value_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return immediate(subject, accept);
 		}
 
 		// General purpose visit operation which actually performs the type check
 		template <class Accept>
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
-			// Check known address values before the map lookup
-			// TODO: Fix it
-			// if (equal_(subject, undefined_)) {
-			// 	return (*this)(napi::value<undefined_tag>::from(subject), accept);
-			// } else if (equal_(subject, null_)) {
-			// 	return (*this)(napi::value<null_tag>::from(subject), accept);
-			// }
 
 			// Check the reference map, and lookup type via napi
-			return this->lookup_or_visit(accept, subject, [ & ]() -> accept_target_t<Accept> {
-				auto typeof = napi::invoke(napi_typeof, napi_env{*this}, subject);
-				switch (typeof) {
+			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+				auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+				switch (type_of) {
 					case napi_undefined:
-						return (*this)(napi::value<undefined_tag>::from(subject), accept);
+						return (*this)(value_of<undefined_tag>::from(subject), accept);
 					case napi_null:
-						return (*this)(napi::value<null_tag>::from(subject), accept);
+						return (*this)(value_of<null_tag>::from(subject), accept);
 					case napi_boolean:
-						return (*this)(napi::value<boolean_tag>::from(subject), accept);
+						return (*this)(value_of<boolean_tag>::from(subject), accept);
 					case napi_number:
-						return (*this)(napi::value<number_tag>::from(subject), accept);
+						return (*this)(value_of<number_tag>::from(subject), accept);
 					case napi_string:
-						return immediate(napi::value<string_tag>::from(subject), accept);
+						return immediate(value_of<string_tag>::from(subject), accept);
 					case napi_symbol:
-						return (*this)(napi::value<symbol_tag>::from(subject), accept);
+						return immediate(value_of<symbol_tag>::from(subject), accept);
 					case napi_object:
 						{
 							if (napi::invoke(napi_is_array, napi_env{*this}, subject)) {
-								return immediate(napi::value<list_tag>::from(subject), accept);
+								return immediate(value_of<list_tag>::from(subject), accept);
 							} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
-								return immediate(napi::value<date_tag>::from(subject), accept);
+								return immediate(value_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);
+							} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
+								return immediate(value_of<data_view_tag>::from(subject), accept);
+							} else if (std::bit_cast<v8::Local<v8::Object>>(subject)->IsSharedArrayBuffer()) {
+								return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+							} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
+								return immediate(value_of<array_buffer_tag>::from(subject), accept);
 							} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
-								return immediate(napi::value<promise_tag>::from(subject), accept);
+								return immediate(value_of<promise_tag>::from(subject), accept);
+							} else {
+								return immediate(value_of<dictionary_tag>::from(subject), accept);
 							}
-							return immediate(napi::value<object_tag>::from(subject), accept);
 						}
 					case napi_function:
-						return immediate(napi::value<function_tag>::from(subject), accept);
+						return immediate(value_of<function_tag>::from(subject), accept);
 					case napi_external:
-						return immediate(napi::value<external_tag>::from(subject), accept);
+						return immediate(value_of<external_tag>::from(subject), accept);
 					case napi_bigint:
-						return immediate(napi::value<bigint_tag>::from(subject), accept);
+						return immediate(value_of<bigint_tag>::from(subject), accept);
 				}
+				std::unreachable();
 			});
 		}
 
-		// no required types
+		// extras
+		[[nodiscard]] auto environment() const -> Environment& { return env_; }
+		explicit operator napi_env() const { return napi_env{env_.get()}; }
 		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
 
 	private:
-		// Private visit operations for refable types
+		// I think this only applies to `symbol_tag`
+		template <class Accept, class Tag>
+			requires std::is_base_of_v<primitive_tag, Tag>
+		auto immediate(value_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> {
+			if (std::bit_cast<v8::Local<v8::String>>(subject)->IsOneByte()) {
+				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
+			} else {
+				return accept_tagged(value_of<string_tag_of<char>>::from(subject), accept);
+			}
+		}
+
+		// bigint
 		template <class Accept>
-		auto immediate(value<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(napi::value<string_tag_of<char16_t>>::from(subject), 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);
 		}
 
+		// date
 		template <class Accept>
-		auto immediate(value<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(value_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
+		// data blocks
 		template <class Accept>
-		auto immediate(value<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
+				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+			} else {
+				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+			}
+		}
+
+		template <class Accept, class Tag>
+			requires std::is_base_of_v<data_block_tag, Tag>
+		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
+		// array buffer views
 		template <class Accept>
-		auto immediate(value<external_tag> subject, const Accept& accept) -> accept_target_t<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);
+			if (bound_subject_variant.index() == std::variant_npos) {
+				std::unreachable();
+			} else {
+				return std::visit(
+					[ & ]<class Tag>(bound_value<Tag> value) -> accept_target_t<Accept> {
+						return accept(Tag{}, *this, value);
+					},
+					bound_subject_variant
+				);
+			}
+		}
+
+		template <class Accept>
+		auto immediate(value_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
+		// externals
 		template <class Accept>
-		auto immediate(value<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(value_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
+		// promise
 		template <class Accept>
-		auto immediate(value<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(napi::value<bigint_tag_of<bigint>>::from(subject), accept);
+		auto immediate(value_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(subject, accept);
 		}
 
+		// function
 		template <class Accept>
-		auto immediate(value<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			// nb: It is intentional that `dictionary_tag` is bound. It handles sparse arrays.
-			auto target = napi::bound_value{napi_env{*this}, napi::value<dictionary_tag>::from(subject)};
-			auto visit_entry = visit_entry_pair<visit_napi_property_name<visit_napi_value>, visit_napi_value&>{*this};
+		auto immediate(value_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 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<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto target = napi::bound_value{napi_env{*this}, napi::value<dictionary_tag>::from(subject)};
-			auto visit_entry = visit_entry_pair<visit_napi_property_name<visit_napi_value>, visit_napi_value&>{*this};
+		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 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`.
-		template <auto_tag Tag, class Accept>
-		[[nodiscard]] auto accept_tagged(value<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(Tag{}, *this, napi::bound_value{napi_env{*this}, subject});
+		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});
 		}
 
-		napi::address_equal equal_;
-		napi_value undefined_{napi::null_value_handle};
-		napi_value null_{napi::null_value_handle};
+		std::reference_wrapper<Environment> env_;
 };
 
-// Napi value visitor entry
-template <class Meta>
-struct visit<Meta, napi_value> : visit_napi_value_with<Meta> {
-		using visit_napi_value_with<Meta>::visit_napi_value_with;
-};
+} // namespace js::napi
+
+namespace js {
 
+// Napi value visitor entry
 template <class Meta>
-struct visit<Meta, value<value_tag>> : visit_napi_value_with<Meta> {
-		using visit_napi_value_with<Meta>::visit_napi_value_with;
+struct visit<Meta, napi_value> : napi::visit_value_with<Meta> {
+		using napi::visit_value_with<Meta>::visit_value_with;
 };
 
-template <class Meta>
-struct visit<Meta, value<object_tag>> : visit_napi_value_with<Meta> {
-		using visit_napi_value_with<Meta>::visit_napi_value_with;
+template <class Meta, class Tag>
+struct visit<Meta, napi::value_of<Tag>> : napi::visit_value_with<Meta> {
+		using napi::visit_value_with<Meta>::visit_value_with;
 };
 
 // Object key maker via napi
 template <auto Key>
-struct visit_key_literal<Key, napi_value> : util::non_moveable {
-	public:
-		explicit constexpr visit_key_literal(auto* /*transfer*/) {}
-
-		auto operator()(const auto& /*could_be_literally_anything*/, const auto& accept_or_visit) -> napi_value {
-			if (local_key_ == napi_value{}) {
-				auto& environment = accept_or_visit.environment();
-				auto storage = environment.string_table_storage(Key);
-				if (storage) {
-					auto& reference = *storage;
-					if (reference) {
-						local_key_ = reference.get(environment);
-					} else {
-						auto value = napi::value<string_tag>::make_property_name(environment, util::consteval_string_view{Key});
-						reference.reset(environment, value);
-						local_key_ = napi_value{value};
-					}
-				} else {
-					return napi::value<string_tag>::make_property_name(environment, util::consteval_string_view{Key});
-				}
-			}
-			return local_key_;
-		}
-
-	private:
-		napi_value local_key_{};
+struct visit_key_literal<Key, napi_value> : napi::visit_napi_key_literal<Key> {
+		using napi::visit_napi_key_literal<Key>::visit_napi_key_literal;
 };
 
 } // namespace js

package/value/array.cc

@@ -1,5 +1,3 @@
-module;
-#include <cstdint>
 module napi_js;
 import :api;
 import :bound_value;
@@ -14,7 +12,7 @@ auto bound_value_for_vector::end() const -> iterator {
 	return {*this, size()};
 }
 
-auto bound_value_for_vector::size() const -> uint32_t {
+auto bound_value_for_vector::size() const -> std::uint32_t {
 	if (size_ == 0) {
 		size_ = napi::invoke(napi_get_array_length, env(), napi_value{*this}) + 1;
 	}

package/value/array.h.cc

@@ -1,12 +1,6 @@
-module;
-#include <compare>
-#include <cstdint>
 export module napi_js:array;
-import :bound_value;
 import :object;
-import :value_handle;
 import auto_js;
-import nodejs;
 import util;
 
 namespace js::napi {
@@ -15,21 +9,21 @@ class bound_value_for_vector : public bound_value_next<vector_tag> {
 	public:
 		class iterator;
 		using bound_value_next<vector_tag>::bound_value_next;
-		using value_type = value<value_tag>;
+		using value_type = value_of<value_tag>;
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
-		[[nodiscard]] auto size() const -> uint32_t;
+		[[nodiscard]] auto size() const -> std::uint32_t;
 
 	private:
-		mutable uint32_t size_{};
+		mutable std::uint32_t size_{};
 };
 
-class bound_value_for_vector::iterator : public util::random_access_iterator_facade<int32_t, int64_t> {
+class bound_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 = uint32_t;
+		using size_type = std::uint32_t;
 		using value_type = bound_value_for_vector::value_type;
 
 		iterator() = default;

package/value/array_buffer.cc

@@ -0,0 +1,109 @@
+module napi_js;
+import :api;
+import :array_buffer;
+import std;
+import v8;
+
+namespace js::napi {
+
+// `bound_value_for_array_buffer`
+bound_value_for_array_buffer::operator js::array_buffer() const {
+	return js::array_buffer{std::span<std::byte>{*this}};
+}
+
+bound_value_for_array_buffer::operator std::span<std::byte>() const {
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	void* bytes;
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	std::size_t byte_length;
+	napi::invoke0(napi_get_arraybuffer_info, env(), napi_value{*this}, &bytes, &byte_length);
+	return std::span<std::byte>{reinterpret_cast<std::byte*>(bytes), byte_length};
+}
+
+// `bound_value_for_shared_array_buffer`
+bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
+	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
+	auto backing_store = local->GetBackingStore();
+	auto* data = reinterpret_cast<std::byte*>(backing_store->Data());
+	auto data_shared_ptr = std::shared_ptr<js::shared_array_buffer::array_type>{std::move(backing_store), data};
+	return js::shared_array_buffer{local->ByteLength(), std::move(data_shared_ptr)};
+}
+
+bound_value_for_shared_array_buffer::operator std::span<std::byte>() const {
+	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
+	return std::span<std::byte>{reinterpret_cast<std::byte*>(local->Data()), local->ByteLength()};
+}
+
+// `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));
+}
+
+// `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 {
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	napi_typedarray_type type_tag;
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	napi_value array_buffer;
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	std::size_t length;
+	// 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}};
+	};
+	switch (type_tag) {
+		case napi_bigint64_array: return make(typed_array_tag_of<std::int64_t>{});
+		case napi_biguint64_array: return make(typed_array_tag_of<std::uint64_t>{});
+		case napi_float16_array: throw std::logic_error{"unsupported"};
+		case napi_float32_array: return make(typed_array_tag_of<float>{});
+		case napi_float64_array: return make(typed_array_tag_of<double>{});
+		case napi_int16_array: return make(typed_array_tag_of<std::int16_t>{});
+		case napi_int32_array: return make(typed_array_tag_of<std::int32_t>{});
+		case napi_int8_array: return make(typed_array_tag_of<std::int8_t>{});
+		case napi_uint16_array: return make(typed_array_tag_of<std::uint16_t>{});
+		case napi_uint32_array: return make(typed_array_tag_of<std::uint32_t>{});
+		case napi_uint8_array: return make(typed_array_tag_of<std::uint8_t>{});
+		case napi_uint8_clamped_array: return make(typed_array_tag_of<std::byte>{});
+	}
+	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> {
+	if (napi::invoke(napi_is_arraybuffer, napi_env{env}, buffer)) {
+		return make(env, value_of<array_buffer_tag>::from(buffer), byte_offset, length);
+	} else {
+		return make(env, value_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 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 buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
+	auto view_local = v8::DataView::New(buffer_local, byte_offset, length);
+	return value_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
+}
+
+// `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{
+			env,
+			data_view,
+			[ & ] -> auto {
+				// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+				napi_value array_buffer;
+				// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+				std::size_t length;
+				// 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};
+			}(),
+		} {}
+
+} // namespace js::napi