@auto_js/napi 0.0.1 → 0.0.2

package/value/array_buffer.h.cc

@@ -0,0 +1,150 @@
+export module napi_js:array_buffer;
+import :bound_value;
+import :environment;
+import :object;
+import std;
+import v8;
+
+namespace js::napi {
+
+// `ArrayBuffer`
+class bound_value_for_array_buffer : public bound_value_next<array_buffer_tag> {
+	public:
+		using bound_value_next<array_buffer_tag>::bound_value_next;
+
+		explicit operator js::array_buffer() const;
+		explicit operator std::span<std::byte>() const;
+};
+
+// `SharedArrayBuffer`
+class bound_value_for_shared_array_buffer : public bound_value_next<shared_array_buffer_tag> {
+	public:
+		using bound_value_next<shared_array_buffer_tag>::bound_value_next;
+
+		explicit operator js::shared_array_buffer() const;
+		explicit operator std::span<std::byte>() const;
+};
+
+// `ArrayBufferView` (hidden superclass of `TypedArray` and `DataView`)
+class bound_value_for_array_buffer_view : public bound_value_next<array_buffer_view_tag> {
+	protected:
+		bound_value_for_array_buffer_view(
+			napi_env env,
+			value_of<array_buffer_view_tag> typed_array,
+			std::tuple<value_of<data_block_tag>, std::size_t, std::size_t> array_buffer_info
+		) :
+				bound_value_next<array_buffer_view_tag>{env, typed_array},
+				array_buffer_{std::get<0>(array_buffer_info)},
+				byte_offset_{std::get<1>(array_buffer_info)},
+				length_{std::get<2>(array_buffer_info)} {}
+
+	public:
+		[[nodiscard]] auto buffer() const -> value_of<data_block_tag> { return array_buffer_; }
+		[[nodiscard]] auto byte_offset() const -> std::size_t { return byte_offset_; }
+		[[nodiscard]] auto size() const -> std::size_t { return length_; }
+
+	private:
+		value_of<data_block_tag> array_buffer_;
+		std::size_t byte_offset_;
+		std::size_t length_;
+};
+
+// `TypedArray`
+class value_for_typed_array : public value_next<typed_array_tag> {
+	protected:
+		static auto make(const environment& env, napi_typedarray_type type, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag>;
+		static auto make(const environment& env, napi_typedarray_type type, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag>;
+};
+
+class bound_value_for_typed_array : public bound_value_next<typed_array_tag> {
+	public:
+		using bound_value_next<typed_array_tag>::bound_value_next;
+		using any_bound_typed_array = std::variant<
+			bound_value<typed_array_tag_of<double>>,
+			bound_value<typed_array_tag_of<float>>,
+			bound_value<typed_array_tag_of<std::byte>>,
+			bound_value<typed_array_tag_of<std::int16_t>>,
+			bound_value<typed_array_tag_of<std::int32_t>>,
+			bound_value<typed_array_tag_of<std::int64_t>>,
+			bound_value<typed_array_tag_of<std::int8_t>>,
+			bound_value<typed_array_tag_of<std::uint16_t>>,
+			bound_value<typed_array_tag_of<std::uint32_t>>,
+			bound_value<typed_array_tag_of<std::uint64_t>>,
+			bound_value<typed_array_tag_of<std::uint8_t>>>;
+
+		static auto make_bound(const environment& env, value_of<typed_array_tag> typed_array) -> any_bound_typed_array;
+};
+
+template <class Type>
+class value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
+	public:
+		using value_next<typed_array_tag_of<Type>>::value_next;
+
+		static auto make(const environment& env, value_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+			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);
+			}
+		}
+
+		static auto make(const environment& env, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+			constexpr auto type_tag = util::overloaded{
+				[](std::type_identity<double>) -> napi_typedarray_type { return napi_float64_array; },
+				[](std::type_identity<float>) -> napi_typedarray_type { return napi_float32_array; },
+				[](std::type_identity<std::byte>) -> napi_typedarray_type { return napi_uint8_clamped_array; },
+				[](std::type_identity<std::int16_t>) -> napi_typedarray_type { return napi_int16_array; },
+				[](std::type_identity<std::int32_t>) -> napi_typedarray_type { return napi_int32_array; },
+				[](std::type_identity<std::int64_t>) -> napi_typedarray_type { return napi_bigint64_array; },
+				[](std::type_identity<std::int8_t>) -> napi_typedarray_type { return napi_int8_array; },
+				[](std::type_identity<std::uint16_t>) -> napi_typedarray_type { return napi_uint16_array; },
+				[](std::type_identity<std::uint32_t>) -> napi_typedarray_type { return napi_uint32_array; },
+				[](std::type_identity<std::uint64_t>) -> napi_typedarray_type { return napi_biguint64_array; },
+				[](std::type_identity<std::uint8_t>) -> napi_typedarray_type { return napi_uint8_array; },
+			}(type<Type>);
+			return value_of<typed_array_tag_of<Type>>::from(value_for_typed_array::make(env, type_tag, buffer, byte_offset, length));
+		}
+
+		// napi doesn't provide a way to make a typed array view on a shared array buffer
+		static auto make(const environment& /*env*/, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+			using constructor_type = type_t<util::overloaded{
+				[](std::type_identity<double>) -> std::type_identity<v8::Float64Array> { return {}; },
+				[](std::type_identity<float>) -> std::type_identity<v8::Float32Array> { return {}; },
+				[](std::type_identity<std::byte>) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
+				[](std::type_identity<std::int16_t>) -> std::type_identity<v8::Int16Array> { return {}; },
+				[](std::type_identity<std::int32_t>) -> std::type_identity<v8::Int32Array> { return {}; },
+				[](std::type_identity<std::int64_t>) -> std::type_identity<v8::BigInt64Array> { return {}; },
+				[](std::type_identity<std::int8_t>) -> std::type_identity<v8::Int8Array> { return {}; },
+				[](std::type_identity<std::uint16_t>) -> std::type_identity<v8::Uint16Array> { return {}; },
+				[](std::type_identity<std::uint32_t>) -> std::type_identity<v8::Uint32Array> { return {}; },
+				[](std::type_identity<std::uint64_t>) -> std::type_identity<v8::BigUint64Array> { return {}; },
+				[](std::type_identity<std::uint8_t>) -> std::type_identity<v8::Uint8Array> { return {}; },
+			}(type<Type>)>;
+			auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
+			auto view_local = constructor_type::New(buffer_local, byte_offset, length);
+			return value_of<typed_array_tag_of<Type>>::from(std::bit_cast<napi_value>(view_local));
+		}
+};
+
+template <class Type>
+class bound_value_for_typed_array_of : public bound_value_next<typed_array_tag_of<Type>> {
+	public:
+		using bound_value_next<typed_array_tag_of<Type>>::bound_value_next;
+};
+
+// `DataView`
+class value_for_data_view : public value_next<data_view_tag> {
+	public:
+		using value_next<data_view_tag>::value_next;
+
+		static auto make(const environment& env, value_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag>;
+		static auto make(const environment& env, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag>;
+		static auto 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>;
+};
+
+class bound_value_for_data_view : public bound_value_next<data_view_tag> {
+	public:
+		bound_value_for_data_view(napi_env env, value_of<data_view_tag> data_view);
+};
+
+} // namespace js::napi

package/value/class.cc

@@ -1,28 +1,19 @@
-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 std;
 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>
+auto value_for_class_of<Type>::construct(auto& env, Args&&... args) const -> value_of<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)...};
+		std::ignore = 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{});
@@ -34,7 +25,7 @@ auto value_for_class_of<Type>::runtime_construct(
 	auto& env,
 	std::tuple<HostArgs...> host_args,
 	std::tuple<RuntimeArgs...> runtime_args
-) const -> value<object_tag>
+) const -> value_of<object_tag>
 	requires std::constructible_from<Type, HostArgs...> {
 	const auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
 	// NOLINTNEXTLINE(bugprone-use-after-move)
@@ -44,7 +35,7 @@ auto value_for_class_of<Type>::runtime_construct(
 
 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> {
+auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value_of<object_tag> {
 	using element_type = decltype(instance)::element_type;
 	auto construct = [ & ](napi_value this_arg) mutable -> napi_value {
 		// Tag `this_arg`
@@ -60,16 +51,16 @@ auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std:
 	// 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* construct_external = napi_value{value_of<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);
+	return value_of<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>> {
+auto value_for_class_of<Type>::make(Environment& env, const auto& class_template) -> value_of<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));
@@ -79,7 +70,7 @@ auto value_for_class_of<Type>::make(Environment& env, const auto& class_template
 	// 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)};
+			constexpr auto u8_name = util::make_consteval_string_view(util::transcode_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 {
@@ -100,7 +91,7 @@ auto value_for_class_of<Type>::make(Environment& env, const auto& class_template
 	// 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)};
+			constexpr auto u8_name = util::make_consteval_string_view(util::transcode_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 {
@@ -130,7 +121,7 @@ auto value_for_class_of<Type>::make(Environment& env, const auto& class_template
 	};
 
 	// Finally, define the class
-	constexpr auto u8_name = util::consteval_string_view{util::interpolate_string<char>(class_template.constructor.name)};
+	constexpr auto u8_name = util::make_consteval_string_view(util::transcode_string<char>(class_template.constructor.name));
 	auto result = napi::invoke(
 		napi_define_class,
 		napi_env{env},
@@ -141,7 +132,7 @@ auto value_for_class_of<Type>::make(Environment& env, const auto& class_template
 		property_descriptors.size(),
 		property_descriptors.data()
 	);
-	return js::napi::value<class_tag_of<Type>>::from(result);
+	return js::napi::value_of<class_tag_of<Type>>::from(result);
 }
 
 } // namespace js::napi

package/value/class.h.cc

@@ -1,32 +1,27 @@
-module;
-#include <concepts>
-#include <tuple>
 export module napi_js:class_;
-import :value_handle;
 import :object;
+import std;
 
 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>
+		auto construct(auto& env, Args&&... args) const -> value_of<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>
+		auto runtime_construct(auto& env, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> value_of<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>;
+		auto transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value_of<object_tag>;
 
 		template <class Environment>
-		static auto make(Environment& env, const auto& class_template) -> value<class_tag_of<Type>>;
+		static auto make(Environment& env, const auto& class_template) -> value_of<class_tag_of<Type>>;
 };
 
 } // namespace js::napi

package/value/external.cc

@@ -1,23 +1,19 @@
-module;
-#include <type_traits>
 export module napi_js:external;
 import :api;
 import :bound_value;
 import :object;
-import :value_handle;
+import std;
 
 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>;
+		static auto make(auto& env, void* pointer) -> value_of<external_tag>;
 
 		// tagged
 		template <class Type>
-		static auto make(auto& env, Type* pointer) -> value<external_tag>;
+		static auto make(auto& env, Type* pointer) -> value_of<external_tag>;
 };
 
 class bound_value_for_external : public bound_value_next<external_tag> {
@@ -30,13 +26,13 @@ class bound_value_for_external : public bound_value_next<external_tag> {
 
 // ---
 
-auto value_for_external::make(auto& env, void* pointer) -> value<external_tag> {
+auto value_for_external::make(auto& env, void* pointer) -> value_of<external_tag> {
 	auto* external = napi::invoke(napi_create_external, napi_env{env}, pointer, nullptr, nullptr);
-	return value<external_tag>::from(external);
+	return value_of<external_tag>::from(external);
 }
 
 template <class Type>
-auto value_for_external::make(auto& env, Type* pointer) -> value<external_tag> {
+auto value_for_external::make(auto& env, Type* pointer) -> value_of<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;

package/value/function.cc

@@ -1,13 +1,6 @@
-module;
-#include <array>
-#include <span>
-#include <tuple>
-#include <variant>
-#include <vector>
 export module napi_js:function_definitions;
-import :api;
 import :callback;
-import :function;
+import std;
 
 namespace js::napi {
 
@@ -31,15 +24,15 @@ auto value_for_function::invoke(auto_environment auto& env, std::span<napi_value
 }
 
 template <auto_environment Environment>
-auto value_for_function::make(Environment& env, auto function) -> value<function_tag> {
+auto value_for_function::make(Environment& env, auto function) -> value_of<function_tag> {
 	auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(std::move(function).callback));
-	auto make = [ & ](void* data) -> value<function_tag> {
-		return value<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
+	auto make = [ & ](void* data) -> value_of<function_tag> {
+		return value_of<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
 	};
 	if constexpr (requires { typename decltype(data)::element_type; }) {
 		// Function requires finalizer
 		auto function = make(data.get());
-		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> value<function_tag> {
+		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> value_of<function_tag> {
 			napi::invoke0(napi_add_finalizer, napi_env{env}, function, data, finalize, hint, nullptr);
 			return function;
 		});

package/value/function.h.cc

@@ -1,18 +1,11 @@
-module;
-#include <span>
-#include <variant>
 export module napi_js:function;
-import :environment_fwd;
 import :primitive;
-import :value_handle;
-import util;
+import std;
 
 namespace js::napi {
 
 class value_for_function : public value_next<function_tag> {
 	public:
-		using value_next<function_tag>::value_next;
-
 		template <class Result = std::monostate>
 		auto apply(auto_environment auto& env, auto&& args) -> Result;
 
@@ -20,7 +13,7 @@ class value_for_function : public value_next<function_tag> {
 		auto call(auto_environment auto& env, auto&&... args) -> Result;
 
 		template <auto_environment Environment>
-		static auto make(Environment& env, auto function) -> value<function_tag>;
+		static auto make(Environment& env, auto function) -> value_of<function_tag>;
 
 	private:
 		template <class Result>

package/value/object.cc

@@ -6,8 +6,8 @@ import :value_handle;
 namespace js::napi {
 
 // object
-auto bound_value_for_object::get(napi_value key) const -> value<value_tag> {
-	return value<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
+auto bound_value_for_object::get(napi_value key) const -> value_of<value_tag> {
+	return value_of<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
 }
 
 auto bound_value_for_object::has(napi_value key) const -> bool {
@@ -19,10 +19,6 @@ auto bound_value_for_object::set(napi_value key, napi_value value) -> void {
 }
 
 // date
-auto value_for_date::make(const environment& env, js_clock::time_point date) -> value<date_tag> {
-	return value<date_tag>::from(napi::invoke(napi_create_date, napi_env{env}, date.time_since_epoch().count()));
-}
-
 bound_value_for_date::operator js_clock::time_point() const {
 	return js_clock::time_point{js_clock::duration{napi::invoke(napi_get_date_value, env(), napi_value{*this})}};
 }

package/value/object.h.cc

@@ -1,22 +1,16 @@
-module;
-#include <array>
-#include <tuple>
-#include <utility>
 export module napi_js:object;
 import :api;
 import :bound_value;
 import :environment_fwd;
 import :primitive;
-import :value_handle;
+import std;
 
 namespace js::napi {
 
 // object
 class value_for_object : public value_next<object_tag> {
 	public:
-		using value_next<object_tag>::value_next;
-
-		auto assign(this value<object_tag> self, auto_environment auto& env, auto source) -> void;
+		auto assign(this value_of<object_tag> self, auto_environment auto& env, auto source) -> void;
 };
 
 class bound_value_for_object : public bound_value_next<object_tag> {
@@ -26,19 +20,13 @@ class bound_value_for_object : public bound_value_next<object_tag> {
 		template <class Type>
 		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
 
-		[[nodiscard]] auto get(napi_value key) const -> value<value_tag>;
+		[[nodiscard]] auto get(napi_value key) const -> value_of<value_tag>;
 		[[nodiscard]] auto has(napi_value key) const -> bool;
 
 		auto set(napi_value key, napi_value value) -> void;
 };
 
 // date
-class value_for_date : public value_next<date_tag> {
-	public:
-		using value_next<date_tag>::value_next;
-		static auto make(const environment& env, js_clock::time_point date) -> value<date_tag>;
-};
-
 class bound_value_for_date : public bound_value_next<date_tag> {
 	public:
 		using bound_value_next<date_tag>::bound_value_next;
@@ -56,4 +44,8 @@ auto bound_value_for_object::try_cast(std::type_identity<Type> /*type*/) const -
 	}
 }
 
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125144
+template class bound_value_next<data_block_tag>;
+template class bound_value_next<array_buffer_view_tag>;
+
 } // namespace js::napi

package/value/primitive.cc

@@ -1,83 +1,38 @@
-module;
-#include <cstdint>
-#include <string>
-#include <string_view>
 module napi_js;
 import :api;
 import :bound_value;
 import :value_handle;
+import std;
 
 namespace js::napi {
 
-// undefined
-auto value_for_undefined::make(const environment& env) -> value<undefined_tag> {
-	return value<undefined_tag>::from(napi::invoke(napi_get_undefined, napi_env{env}));
-}
-
-// null
-auto value_for_null::make(const environment& env) -> value<null_tag> {
-	return value<null_tag>::from(napi::invoke(napi_get_null, napi_env{env}));
-}
-
 // boolean
-auto value_for_boolean::make(const environment& env, bool boolean) -> value<boolean_tag> {
-	return value<boolean_tag>::from(napi::invoke(napi_get_boolean, napi_env{env}, boolean));
-}
-
 bound_value_for_boolean::operator bool() const {
 	return napi::invoke(napi_get_value_bool, env(), napi_value{*this});
 }
 
 // number
-auto value_for_number::make(const environment& env, double number) -> value<number_tag> {
-	return value<number_tag>::from(napi::invoke(napi_create_double, napi_env{env}, number));
-}
-
-auto value_for_number::make(const environment& env, int32_t number) -> value<number_tag> {
-	return value<number_tag>::from(napi::invoke(napi_create_int32, napi_env{env}, number));
-}
-
-auto value_for_number::make(const environment& env, int64_t number) -> value<number_tag> {
-	return value<number_tag>::from(napi::invoke(napi_create_int64, napi_env{env}, number));
-}
-
-auto value_for_number::make(const environment& env, uint32_t number) -> value<number_tag> {
-	return value<number_tag>::from(napi::invoke(napi_create_uint32, napi_env{env}, number));
-}
-
 bound_value_for_number::operator double() const {
 	return napi::invoke(napi_get_value_double, env(), napi_value{*this});
 }
 
-bound_value_for_number::operator int32_t() const {
+bound_value_for_number::operator std::int32_t() const {
 	return napi::invoke(napi_get_value_int32, env(), napi_value{*this});
 }
 
-bound_value_for_number::operator int64_t() const {
+bound_value_for_number::operator std::int64_t() const {
 	return napi::invoke(napi_get_value_int64, env(), napi_value{*this});
 }
 
-bound_value_for_number::operator uint32_t() const {
+bound_value_for_number::operator std::uint32_t() const {
 	return napi::invoke(napi_get_value_uint32, env(), napi_value{*this});
 }
 
 // bigint
-auto value_for_bigint::make(const environment& env, const bigint& number) -> value<bigint_tag> {
-	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_words, napi_env{env}, number.sign_bit(), number.size(), number.data()));
-}
-
-auto value_for_bigint::make(const environment& env, int64_t number) -> value<bigint_tag> {
-	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_int64, napi_env{env}, number));
-}
-
-auto value_for_bigint::make(const environment& env, uint64_t number) -> value<bigint_tag> {
-	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_uint64, napi_env{env}, number));
-}
-
 bound_value_for_bigint::operator bigint() const {
 	js::bigint value;
-	auto one_word = uint64_t{};
-	auto length = size_t{1};
+	auto one_word = std::uint64_t{};
+	auto length = std::size_t{1};
 	napi::invoke0(napi_get_value_bigint_words, env(), napi_value{*this}, &value.sign_bit(), &length, &one_word);
 	if (value.sign_bit() == 0 && length == 1) {
 		return js::bigint{one_word};
@@ -91,52 +46,28 @@ bound_value_for_bigint::operator bigint() const {
 	return value;
 }
 
-bound_value_for_bigint::operator int64_t() const {
+bound_value_for_bigint::operator std::int64_t() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-	int64_t value;
+	std::int64_t value;
 	// nb: `lossless` error not checked for consistency with `napi_get_value_int32`,
 	// `napi_get_value_string_latin1`, etc which don't return any errors.
 	napi::invoke(napi_get_value_bigint_int64, env(), napi_value{*this}, &value);
 	return value;
 }
 
-bound_value_for_bigint::operator uint64_t() const {
+bound_value_for_bigint::operator std::uint64_t() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-	uint64_t value;
+	std::uint64_t value;
 	napi::invoke(napi_get_value_bigint_uint64, env(), napi_value{*this}, &value);
 	return value;
 }
 
 // string
-auto value_for_string::make(const environment& env, std::string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(napi_create_string_latin1, napi_env{env}, string.data(), string.length()));
-}
-
-auto value_for_string::make(const environment& env, std::u8string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(napi_create_string_utf8, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
-}
-
-auto value_for_string::make(const environment& env, std::u16string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(napi_create_string_utf16, napi_env{env}, string.data(), string.length()));
-}
-
-auto value_for_string::make_property_name(const environment& env, std::string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(node_api_create_property_key_latin1, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
-}
-
-auto value_for_string::make_property_name(const environment& env, std::u8string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(node_api_create_property_key_utf8, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
-}
-
-auto value_for_string::make_property_name(const environment& env, std::u16string_view string) -> value<string_tag> {
-	return value<string_tag>::from(napi::invoke(node_api_create_property_key_utf16, napi_env{env}, string.data(), string.length()));
-}
-
 bound_value_for_string::operator std::string() const {
 	std::string string;
 	auto length = napi::invoke(napi_get_value_string_latin1, env(), napi_value{*this}, nullptr, 0);
 	if (length > 0) {
-		string.resize_and_overwrite(length + 1, [ this ](char* data, size_t length) noexcept -> size_t {
+		string.resize_and_overwrite(length + 1, [ this ](char* data, std::size_t length) noexcept -> std::size_t {
 			napi::invoke_noexcept(napi_get_value_string_latin1, env(), napi_value{*this}, data, length);
 			return length - 1;
 		});
@@ -149,7 +80,7 @@ bound_value_for_string::operator std::u16string() const {
 	std::u16string string;
 	auto length = napi::invoke(napi_get_value_string_utf16, env(), napi_value{*this}, nullptr, 0);
 	if (length > 0) {
-		string.resize_and_overwrite(length + 1, [ this ](char16_t* data, size_t length) noexcept -> size_t {
+		string.resize_and_overwrite(length + 1, [ this ](char16_t* data, std::size_t length) noexcept -> std::size_t {
 			napi::invoke_noexcept(napi_get_value_string_utf16, env(), napi_value{*this}, data, length);
 			return length - 1;
 		});