From 408e1d292f739fb9ea995753098006bf71a933c4 Mon Sep 17 00:00:00 2001
From: Jeff Raymakers <jephly@gmail.com>
Date: Sat, 22 Jun 2024 15:20:13 -0700
Subject: [PATCH] fix linux build errors

---
 binding.gyp              |   3 +-
 src/value_conversion.hpp | 569 ++++++++++++++++++++-------------------
 2 files changed, 287 insertions(+), 285 deletions(-)

diff --git a/binding.gyp b/binding.gyp
index 7c5ecd9f..2067762e 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -29,7 +29,8 @@
             "cflags_cc": [
                 "-frtti", 
                 "-fexceptions", 
-                "-Wno-redundant-move"
+                "-Wno-redundant-move",
+                "-std=c++20"
             ], 
             "cflags_cc!": [
                 "-fno-rrti", 
diff --git a/src/value_conversion.hpp b/src/value_conversion.hpp
index 1bc7ae3d..5d5d9102 100644
--- a/src/value_conversion.hpp
+++ b/src/value_conversion.hpp
@@ -73,363 +73,364 @@ struct out_string_wrapper {
 
 class ValueConversion {
 public:
-	template <class T, typename fake = void>
+	template <class T>
 	static Napi::Value ToJS(Napi::Env &env, T val) {
 		// static_assert(false, "Unimplemented value conversion to JS");
 		throw std::logic_error("Unimplemented value conversion to JS");
 	}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_state val) {
-		return Napi::Number::New(env, (uint8_t)val);
+	template <class T>
+	static T FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+		// static_assert(false, "Unimplemented value conversion from JS");
+		throw std::logic_error("Unimplemented value conversion from JS");
 	}
+};
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_result_type val) {
-		return Napi::Number::New(env, (uint8_t)val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_state val) {
+	return Napi::Number::New(env, (uint8_t)val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_pending_state val) {
-		return Napi::Number::New(env, (uint8_t)val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_result_type val) {
+	return Napi::Number::New(env, (uint8_t)val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_type val) {
-		return Napi::Number::New(env, (uint8_t)val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_pending_state val) {
+	return Napi::Number::New(env, (uint8_t)val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_data_chunk val) {
-		return PointerHolder<duckdb_data_chunk>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_type val) {
+	return Napi::Number::New(env, (uint8_t)val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_query_progress_type val) {
-		return PointerHolder<duckdb_query_progress_type>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_data_chunk val) {
+	return PointerHolder<duckdb_data_chunk>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_value val) {
-		return PointerHolder<duckdb_value>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_query_progress_type val) {
+	return PointerHolder<duckdb_query_progress_type>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_vector val) {
-		return PointerHolder<duckdb_vector>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_value val) {
+	return PointerHolder<duckdb_value>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_logical_type val) {
-		return PointerHolder<duckdb_logical_type>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_vector val) {
+	return PointerHolder<duckdb_vector>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, void *val) {
-		return PointerHolder<void *>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_logical_type val) {
+	return PointerHolder<duckdb_logical_type>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, uint64_t *val) {
-		return PointerHolder<uint64_t *>::NewAndSet(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, void *val) {
+	return PointerHolder<void *>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, duckdb_string val) {
-		auto ret = Napi::String::New(env, val.data, val.size);
-		duckdb_free(val.data);
-		return ret;
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, uint64_t *val) {
+	return PointerHolder<uint64_t *>::NewAndSet(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, const char *val) {
-		return Napi::String::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, duckdb_string val) {
+	auto ret = Napi::String::New(env, val.data, val.size);
+	duckdb_free(val.data);
+	return ret;
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, char *val) {
-		return Napi::String::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, const char *val) {
+	return Napi::String::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, int32_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, char *val) {
+	return Napi::String::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, uint32_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, int32_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, idx_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, uint32_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, bool val) {
-		return Napi::Boolean::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, idx_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, double val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, bool val) {
+	return Napi::Boolean::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, size_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, double val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, int8_t val) {
-		return Napi::Number::New(env, val);
-	}
+// template <>
+// Napi::Value ValueConversion::ToJS(Napi::Env &env, size_t val) {
+// 	return Napi::Number::New(env, val);
+// }
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, int16_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, int8_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, int64_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, int16_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, uint8_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, int64_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, uint16_t val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, uint8_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	Napi::Value ToJS(Napi::Env &env, float val) {
-		return Napi::Number::New(env, val);
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, uint16_t val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <class T, typename fake = void>
-	static T FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		// static_assert(false, "Unimplemented value conversion from JS");
-		throw std::logic_error("Unimplemented value conversion from JS");
-	}
+template <>
+Napi::Value ValueConversion::ToJS(Napi::Env &env, float val) {
+	return Napi::Number::New(env, val);
+}
 
-	template <>
-	std::string FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::String>();
-	}
+template <>
+std::string ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::String>();
+}
 
-	template <>
-	duckdb_database *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_database>::FromInfo(info, offset);
-	}
+template <>
+duckdb_database *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_database>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_database FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_database *>(info, offset);
-	}
+template <>
+duckdb_database ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_database *>(info, offset);
+}
 
-	template <>
-	duckdb_query_progress_type *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_query_progress_type>::FromInfo(info, offset);
-	}
+template <>
+duckdb_query_progress_type *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_query_progress_type>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_query_progress_type FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_query_progress_type *>(info, offset);
-	}
+template <>
+duckdb_query_progress_type ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_query_progress_type *>(info, offset);
+}
 
-	template <>
-	duckdb_connection *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_connection>::FromInfo(info, offset);
-	}
+template <>
+duckdb_connection *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_connection>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_connection FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_connection *>(info, offset);
-	}
+template <>
+duckdb_connection ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_connection *>(info, offset);
+}
 
-	template <>
-	duckdb_config *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_config>::FromInfo(info, offset);
-	}
+template <>
+duckdb_config *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_config>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_config FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_config *>(info, offset);
-	}
+template <>
+duckdb_config ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_config *>(info, offset);
+}
 
-	template <>
-	duckdb_result *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_result>::FromInfo(info, offset);
-	}
+template <>
+duckdb_result *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_result>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_result FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_result *>(info, offset);
-	}
+template <>
+duckdb_result ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_result *>(info, offset);
+}
 
-	template <>
-	duckdb_prepared_statement *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_prepared_statement>::FromInfo(info, offset);
-	}
+template <>
+duckdb_prepared_statement *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_prepared_statement>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_prepared_statement FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_prepared_statement *>(info, offset);
-	}
+template <>
+duckdb_prepared_statement ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_prepared_statement *>(info, offset);
+}
 
-	template <>
-	duckdb_appender *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_appender>::FromInfo(info, offset);
-	}
+template <>
+duckdb_appender *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_appender>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_appender FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_appender *>(info, offset);
-	}
+template <>
+duckdb_appender ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_appender *>(info, offset);
+}
 
-	template <>
-	duckdb_data_chunk *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_data_chunk>::FromInfo(info, offset);
-	}
+template <>
+duckdb_data_chunk *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_data_chunk>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_data_chunk FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_data_chunk *>(info, offset);
-	}
+template <>
+duckdb_data_chunk ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_data_chunk *>(info, offset);
+}
 
-	template <>
-	duckdb_vector *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_vector>::FromInfo(info, offset);
-	}
+template <>
+duckdb_vector *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_vector>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_vector FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_vector *>(info, offset);
-	}
+template <>
+duckdb_vector ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_vector *>(info, offset);
+}
 
-	template <>
-	duckdb_pending_result *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_pending_result>::FromInfo(info, offset);
-	}
+template <>
+duckdb_pending_result *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_pending_result>::FromInfo(info, offset);
+}
 
-	template <>
-	const char **FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return &(PointerHolder<out_string_wrapper>::FromInfo(info, offset)->ptr);
-	}
+template <>
+const char **ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return &(PointerHolder<out_string_wrapper>::FromInfo(info, offset)->ptr);
+}
 
-	template <>
-	char **FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return (char **)&(PointerHolder<out_string_wrapper>::FromInfo(info, offset)->ptr);
-	}
+template <>
+char **ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return (char **)&(PointerHolder<out_string_wrapper>::FromInfo(info, offset)->ptr);
+}
 
-	template <>
-	duckdb_pending_result FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_pending_result *>(info, offset);
-	}
+template <>
+duckdb_pending_result ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_pending_result *>(info, offset);
+}
 
-	template <>
-	duckdb_pending_state FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return (duckdb_pending_state)GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+duckdb_pending_state ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return (duckdb_pending_state)GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	duckdb_type FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return (duckdb_type)GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+duckdb_type ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return (duckdb_type)GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	duckdb_logical_type FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_logical_type *>(info, offset);
-	}
+template <>
+duckdb_logical_type *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_logical_type>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_logical_type *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_logical_type>::FromInfo(info, offset);
-	}
+template <>
+duckdb_logical_type ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_logical_type *>(info, offset);
+}
 
-	template <>
-	duckdb_value FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *FromJS<duckdb_value *>(info, offset);
-	}
+template <>
+duckdb_value *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return PointerHolder<duckdb_value>::FromInfo(info, offset);
+}
 
-	template <>
-	duckdb_value *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return PointerHolder<duckdb_value>::FromInfo(info, offset);
-	}
+template <>
+duckdb_value ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *ValueConversion::FromJS<duckdb_value *>(info, offset);
+}
 
-	template <>
-	void *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *PointerHolder<void *>::FromInfo(info, offset);
-	}
+template <>
+void *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *PointerHolder<void *>::FromInfo(info, offset);
+}
 
-	template <>
-	const void *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *PointerHolder<const void *>::FromInfo(info, offset);
-	}
+template <>
+const void *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *PointerHolder<const void *>::FromInfo(info, offset);
+}
 
-	template <>
-	uint64_t *FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return *PointerHolder<uint64_t *>::FromInfo(info, offset);
-	}
+template <>
+uint64_t *ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return *PointerHolder<uint64_t *>::FromInfo(info, offset);
+}
 
-	template <>
-	idx_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int64Value();
-	}
+template <>
+idx_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int64Value();
+}
 
-	template <>
-	size_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int64Value();
-	}
+// template <>
+// size_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+// 	return GetValue(info, offset).As<Napi::Number>().Int64Value();
+// }
 
-	template <>
-	int64_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int64Value();
-	}
+template <>
+int64_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int64Value();
+}
 
-	template <>
-	int32_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+int32_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	uint32_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+uint32_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	int16_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+int16_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	uint16_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+uint16_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
 
-	template <>
-	float FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().FloatValue();
-	}
+template <>
+float ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().FloatValue();
+}
 
-	template <>
-	double FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().DoubleValue();
-	}
+template <>
+double ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().DoubleValue();
+}
 
-	template <>
-	int8_t FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Number>().Int32Value();
-	}
+template <>
+int8_t ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Number>().Int32Value();
+}
+
+template <>
+bool ValueConversion::FromJS(const Napi::CallbackInfo &info, idx_t offset) {
+	return GetValue(info, offset).As<Napi::Boolean>().Value();
+}
 
-	template <>
-	bool FromJS(const Napi::CallbackInfo &info, idx_t offset) {
-		return GetValue(info, offset).As<Napi::Boolean>().Value();
-	}
-};
 } // namespace duckdb_node
\ No newline at end of file