@auto_js/napi 0.0.1

package/transfer/visit.cc

@@ -0,0 +1,268 @@
+module;
+#include <functional>
+#include <utility>
+export module napi_js:visit;
+import :api;
+import :container;
+import :environment_fwd;
+import :utility;
+import :value;
+import util;
+
+namespace js {
+using namespace napi;
+
+// Instantiated in the acceptor that corresponds to a napi visitor
+struct napi_reference_map_type {
+		template <class Type>
+		using type = napi::value_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 {
+	public:
+		explicit visit_napi_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> {
+				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();
+				}
+			});
+		}
+
+		[[nodiscard]] auto environment() const -> auto& { return visit_.get().environment(); }
+
+	private:
+		std::reference_wrapper<Visit> visit_;
+};
+
+// 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 <class Meta>
+using visit_napi_value_with = visit_napi_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> {
+	public:
+		using reference_map_t<Target, napi_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} {}
+
+		// 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>
+			requires requires { immediate(subject, accept); } {
+			return lookup_or_visit(accept, 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);
+		}
+
+		template <class Accept>
+		auto operator()(value<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			undefined_ = subject;
+			return accept_tagged(subject, accept);
+		}
+
+		template <class Accept>
+		auto operator()(value<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(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);
+		}
+
+		template <class Accept>
+		auto operator()(value<symbol_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(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) {
+					case napi_undefined:
+						return (*this)(napi::value<undefined_tag>::from(subject), accept);
+					case napi_null:
+						return (*this)(napi::value<null_tag>::from(subject), accept);
+					case napi_boolean:
+						return (*this)(napi::value<boolean_tag>::from(subject), accept);
+					case napi_number:
+						return (*this)(napi::value<number_tag>::from(subject), accept);
+					case napi_string:
+						return immediate(napi::value<string_tag>::from(subject), accept);
+					case napi_symbol:
+						return (*this)(napi::value<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);
+							} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
+								return immediate(napi::value<date_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(napi::value<object_tag>::from(subject), accept);
+						}
+					case napi_function:
+						return immediate(napi::value<function_tag>::from(subject), accept);
+					case napi_external:
+						return immediate(napi::value<external_tag>::from(subject), accept);
+					case napi_bigint:
+						return immediate(napi::value<bigint_tag>::from(subject), accept);
+				}
+			});
+		}
+
+		// no required types
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		// Private visit operations for refable types
+		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);
+		}
+
+		template <class Accept>
+		auto immediate(value<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(subject, accept);
+		}
+
+		template <class Accept>
+		auto immediate(value<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(subject, accept);
+		}
+
+		template <class Accept>
+		auto immediate(value<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(subject, accept);
+		}
+
+		template <class Accept>
+		auto immediate(value<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(subject, accept);
+		}
+
+		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);
+		}
+
+		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};
+			return accept(list_tag{}, visit_entry, target);
+		}
+
+		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};
+			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});
+		}
+
+		napi::address_equal equal_;
+		napi_value undefined_{napi::null_value_handle};
+		napi_value null_{napi::null_value_handle};
+};
+
+// 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;
+};
+
+template <class Meta>
+struct visit<Meta, value<value_tag>> : visit_napi_value_with<Meta> {
+		using visit_napi_value_with<Meta>::visit_napi_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;
+};
+
+// 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_{};
+};
+
+} // namespace js

package/value/array.cc

@@ -0,0 +1,32 @@
+module;
+#include <cstdint>
+module napi_js;
+import :api;
+import :bound_value;
+
+namespace js::napi {
+
+auto bound_value_for_vector::begin() const -> iterator {
+	return {*this, 0};
+}
+
+auto bound_value_for_vector::end() const -> iterator {
+	return {*this, size()};
+}
+
+auto bound_value_for_vector::size() const -> 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) :
+		subject_{subject},
+		index_{index} {}
+
+auto bound_value_for_vector::iterator::operator*() const -> value_type {
+	return value_type::from(napi::invoke(napi_get_element, subject_.env(), napi_value{subject_}, index_));
+}
+
+} // namespace js::napi

package/value/array.h.cc

@@ -0,0 +1,55 @@
+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 {
+
+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>;
+
+		[[nodiscard]] auto begin() const -> iterator;
+		[[nodiscard]] auto end() const -> iterator;
+		[[nodiscard]] auto size() const -> uint32_t;
+
+	private:
+		mutable uint32_t size_{};
+};
+
+class bound_value_for_vector::iterator : public util::random_access_iterator_facade<int32_t, int64_t> {
+	public:
+		using arithmetic_facade::operator+;
+		using difference_type = arithmetic_facade::difference_type;
+		using size_type = uint32_t;
+		using value_type = bound_value_for_vector::value_type;
+
+		iterator() = default;
+		iterator(bound_value_for_vector subject, size_type index);
+
+		auto operator*() const -> value_type;
+
+		auto operator+=(difference_type offset) -> iterator& {
+			index_ += offset;
+			return *this;
+		}
+
+		auto operator==(const iterator& right) const -> bool { return index_ == right.index_; }
+		auto operator<=>(const iterator& right) const -> std::strong_ordering { return index_ <=> right.index_; }
+
+	private:
+		auto operator+() const -> size_type { return index_; }
+
+		bound_value_for_vector subject_;
+		size_type index_{};
+};
+
+} // namespace js::napi

package/value/class.cc

@@ -0,0 +1,147 @@
+module;
+#include <algorithm>
+#include <array>
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+export module napi_js:class_definitions;
+import :api;
+import :callback;
+import :class_;
+import :external;
+import util;
+
+namespace js::napi {
+
+template <class Type>
+template <class... Args>
+auto value_for_class_of<Type>::construct(auto& env, Args&&... args) const -> value<object_tag>
+	requires std::constructible_from<Type, Args...> {
+	// NOLINTNEXTLINE(readability-simplify-boolean-expr)
+	if (false) {
+		// nb: Fixes invalid `performance-unnecessary-value-param` lint errors when invoking this function
+		[[maybe_unused]] auto nothing = std::tuple<std::remove_cvref_t<Args>...>{std::forward<Args>(args)...};
+	}
+	// NOLINTNEXTLINE(bugprone-use-after-move)
+	return runtime_construct(env, std::forward_as_tuple(std::forward<Args>(args)...), std::tuple{});
+}
+
+template <class Type>
+template <class... HostArgs, class... RuntimeArgs>
+auto value_for_class_of<Type>::runtime_construct(
+	auto& env,
+	std::tuple<HostArgs...> host_args,
+	std::tuple<RuntimeArgs...> runtime_args
+) const -> value<object_tag>
+	requires std::constructible_from<Type, HostArgs...> {
+	const auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
+	// NOLINTNEXTLINE(bugprone-use-after-move)
+	auto instance = std::make_unique<Type>(std::get<indices>(std::move(host_args))...);
+	return transfer_construct(env, std::move(instance), std::move(runtime_args));
+}
+
+template <class Type>
+template <class... Args>
+auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value<object_tag> {
+	using element_type = decltype(instance)::element_type;
+	auto construct = [ & ](napi_value this_arg) mutable -> napi_value {
+		// Tag `this_arg`
+		napi::invoke0(napi_type_tag_object, napi_env{env}, this_arg, &type_tag_for<element_type>);
+
+		// Wrap w/ finalizer
+		return apply_finalizer(std::move(instance), [ & ](element_type* instance, napi_finalize finalize, void* hint) -> napi_value {
+			napi::invoke0(napi_wrap, napi_env{env}, this_arg, instance, finalize, hint, nullptr);
+			return this_arg;
+		});
+	};
+
+	// Now an external (of `internal_constructor`) gets passed to JavaScript for a moment and
+	// hopefully it jumps into `construct`
+	auto construct_ref = internal_constructor{construct};
+	auto* construct_external = napi_value{value<external_tag>::make(env, &construct_ref)};
+	auto [... runtime_arg_values ] = js::transfer_in_strict<std::array<napi_value, sizeof...(Args)>>(std::move(runtime_args), env);
+	auto arg_vector = std::array{construct_external, runtime_arg_values...};
+	auto* this_arg = napi::invoke(napi_new_instance, napi_env{env}, napi_value{*this}, arg_vector.size(), arg_vector.data());
+	return value<object_tag>::from(this_arg);
+}
+
+template <class Type>
+template <class Environment>
+auto value_for_class_of<Type>::make(Environment& env, const auto& class_template) -> value<class_tag_of<Type>> {
+	// Make constructor callback
+	auto [ construct_ptr, constructor_data ] =
+		make_callback_storage(env, make_constructor_function<Environment, Type>(class_template.constructor.function));
+	static_assert(std::remove_cvref_t<decltype(class_template.constructor)>::disposition == property_disposition::function);
+	static_assert(!requires { typename decltype(constructor_data)::element_type; });
+
+	// Member function property descriptor
+	const auto make_member_function_descriptor = [ & ]<class Property>(const Property& property) -> napi_property_descriptor
+		requires(Property::scope == class_property_scope::prototype) {
+			constexpr auto u8_name = util::consteval_string_view{util::interpolate_string<char>(property.name)};
+			auto [ callback, data ] = make_callback_storage(env, make_member_function<Environment, Type>(property.function));
+			static_assert(!requires { typename decltype(data)::element_type; });
+			return {
+				.utf8name = u8_name.data(),
+				.name{},
+
+				.method = callback,
+				.getter{},
+				.setter{},
+				.value{},
+
+				// NOLINTNEXTLINE(hicpp-signed-bitwise)
+				.attributes = static_cast<napi_property_attributes>(napi_writable | napi_configurable),
+				.data = data,
+			};
+		};
+
+	// Static function property descriptor
+	const auto make_static_function_descriptor = [ & ]<class Property>(const Property& property) -> napi_property_descriptor
+		requires(Property::scope == class_property_scope::constructor) {
+			constexpr auto u8_name = util::consteval_string_view{util::interpolate_string<char>(property.name)};
+			auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(property.function));
+			static_assert(!requires { typename decltype(data)::element_type; });
+			return {
+				.utf8name = u8_name.data(),
+				.name{},
+
+				.method = callback,
+				.getter{},
+				.setter{},
+				.value{},
+
+				// NOLINTNEXTLINE(hicpp-signed-bitwise)
+				.attributes = static_cast<napi_property_attributes>(napi_static | napi_writable | napi_configurable),
+				.data = data,
+			};
+		};
+
+	// Make class property descriptors
+	const auto make_property_descriptor = util::overloaded{
+		make_member_function_descriptor,
+		make_static_function_descriptor,
+	};
+	const auto [... properties ] = class_template.properties;
+	const auto property_descriptors = std::array<napi_property_descriptor, sizeof...(properties)>{
+		// NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
+		make_property_descriptor(properties)...
+	};
+
+	// Finally, define the class
+	constexpr auto u8_name = util::consteval_string_view{util::interpolate_string<char>(class_template.constructor.name)};
+	auto result = napi::invoke(
+		napi_define_class,
+		napi_env{env},
+		u8_name.data(),
+		u8_name.length(),
+		construct_ptr,
+		constructor_data,
+		property_descriptors.size(),
+		property_descriptors.data()
+	);
+	return js::napi::value<class_tag_of<Type>>::from(result);
+}
+
+} // namespace js::napi

package/value/class.h.cc

@@ -0,0 +1,32 @@
+module;
+#include <concepts>
+#include <tuple>
+export module napi_js:class_;
+import :value_handle;
+import :object;
+
+namespace js::napi {
+
+template <class Type>
+class value_for_class_of : public value_next<class_tag_of<Type>> {
+	public:
+		using value_next<class_tag_of<Type>>::value_next;
+
+		// Construct a new C++ instance & JavaScript value
+		template <class... Args>
+		auto construct(auto& env, Args&&... args) const -> value<object_tag>
+			requires std::constructible_from<Type, Args...>;
+
+		template <class... HostArgs, class... RuntimeArgs>
+		auto runtime_construct(auto& env, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> value<object_tag>
+			requires std::constructible_from<Type, HostArgs...>;
+
+		// Create a JavaScript value from an already-created instance smart pointer
+		template <class... Args>
+		auto transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value<object_tag>;
+
+		template <class Environment>
+		static auto make(Environment& env, const auto& class_template) -> value<class_tag_of<Type>>;
+};
+
+} // namespace js::napi

package/value/dictionary.cc

@@ -0,0 +1,33 @@
+module;
+#include <ranges>
+#include <utility>
+module napi_js;
+import :api;
+import :array;
+
+namespace js::napi {
+
+auto dictionary_like::into_range() const -> range_type {
+	return keys() | std::views::transform(iterator_transform{*this});
+}
+
+auto dictionary_like::size() const -> std::size_t {
+	return keys().size();
+}
+
+auto dictionary_like::keys() const -> const keys_type& {
+	if (napi_value{keys_} == nullptr) {
+		auto* property_names = napi::invoke(napi_get_property_names, env(), *this);
+		keys_ = keys_type{env(), js::napi::value<vector_tag>::from(property_names)};
+	}
+	return keys_;
+}
+
+dictionary_like::iterator_transform::iterator_transform(const dictionary_like& subject) :
+		subject_{&subject} {}
+
+auto dictionary_like::iterator_transform::operator()(value<value_tag> key) const -> value_type {
+	return std::pair{key_type::from(key), subject_->get(key)};
+}
+
+} // namespace js::napi

package/value/dictionary.h.cc

@@ -0,0 +1,56 @@
+module;
+#include <ranges>
+export module napi_js:dictionary;
+import :array;
+import :bound_value;
+import :object;
+import :value_handle;
+import auto_js;
+
+namespace js::napi {
+
+// Weird naming here because an object `{}` is a typeof "object", but lots of other things are
+// objects. Also, the object iterator is implemented as transformation on a property names vector
+// (which is also an object). So this needs to be its own class or it is a circular inheritance.
+class dictionary_like : public bound_value<object_tag> {
+	public:
+		using bound_value<object_tag>::bound_value;
+		using keys_type = bound_value<vector_tag>;
+		using key_type = value<primitive_tag>;
+		using mapped_type = value<value_tag>;
+		using value_type = std::pair<key_type, mapped_type>;
+
+	private:
+		class iterator_transform {
+			public:
+				explicit iterator_transform(const dictionary_like& subject_);
+				auto operator()(value<value_tag> key) const -> value_type;
+
+			private:
+				const dictionary_like* subject_;
+		};
+
+	public:
+		using range_type = std::ranges::transform_view<std::views::all_t<const keys_type&>, iterator_transform>;
+		using iterator = std::ranges::iterator_t<range_type>;
+
+		[[nodiscard]] auto into_range() const -> range_type;
+		[[nodiscard]] auto size() const -> std::size_t;
+
+	private:
+		[[nodiscard]] auto keys() const -> const keys_type&;
+
+		mutable keys_type keys_;
+};
+
+class bound_value_for_list : public dictionary_like {
+	public:
+		using dictionary_like::dictionary_like;
+};
+
+class bound_value_for_dictionary : public dictionary_like {
+	public:
+		using dictionary_like::dictionary_like;
+};
+
+} // namespace js::napi

package/value/external.cc

@@ -0,0 +1,54 @@
+module;
+#include <type_traits>
+export module napi_js:external;
+import :api;
+import :bound_value;
+import :object;
+import :value_handle;
+
+namespace js::napi {
+
+class value_for_external : public value_next<external_tag> {
+	public:
+		using value_next<external_tag>::value_next;
+
+		// untagged
+		static auto make(auto& env, void* pointer) -> value<external_tag>;
+
+		// tagged
+		template <class Type>
+		static auto make(auto& env, Type* pointer) -> value<external_tag>;
+};
+
+class bound_value_for_external : public bound_value_next<external_tag> {
+	public:
+		using bound_value_next<external_tag>::bound_value_next;
+
+		template <class Type>
+		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
+};
+
+// ---
+
+auto value_for_external::make(auto& env, void* pointer) -> value<external_tag> {
+	auto* external = napi::invoke(napi_create_external, napi_env{env}, pointer, nullptr, nullptr);
+	return value<external_tag>::from(external);
+}
+
+template <class Type>
+auto value_for_external::make(auto& env, Type* pointer) -> value<external_tag> {
+	auto external = make(env, static_cast<void*>(pointer));
+	napi::invoke0(napi_type_tag_object, napi_env{env}, external, &type_tag_for<Type>);
+	return external;
+};
+
+template <class Type>
+auto bound_value_for_external::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
+	if (napi::invoke(napi_check_object_type_tag, env(), napi_value{*this}, &type_tag_for<Type>)) {
+		return static_cast<Type*>(napi::invoke(napi_get_value_external, env(), napi_value{*this}));
+	} else {
+		return nullptr;
+	}
+}
+
+} // namespace js::napi