diff --git a/cmake/subdir.cmake b/cmake/subdir.cmake
index bb3785289..234a25fcb 100644
--- a/cmake/subdir.cmake
+++ b/cmake/subdir.cmake
@@ -12,6 +12,9 @@ endforeach()
 
 if (NOT ENABLE_CPP_20)
   Set(BUILD_STRUCT_PACK ON)
+  Set(BUILD_STRUCT_JSON ON)
+  Set(BUILD_STRUCT_XML ON)
+  Set(BUILD_STRUCT_YAML ON)
 endif()
 
 foreach(child ${children})
diff --git a/include/ylt/struct_yaml/yaml_reader.h b/include/ylt/struct_yaml/yaml_reader.h
index f38c4c77e..ca8b80bea 100644
--- a/include/ylt/struct_yaml/yaml_reader.h
+++ b/include/ylt/struct_yaml/yaml_reader.h
@@ -18,12 +18,12 @@
 
 namespace struct_yaml {
 
-template <typename T, iguana::string_t View>
+template <typename T, typename View>
 inline void from_yaml(T &value, const View &view) {
   iguana::from_yaml(value, view);
 }
 
-template <typename T, iguana::string_t View>
+template <typename T, typename View>
 inline void from_yaml(T &value, const View &view, std::error_code &ec) {
   iguana::from_yaml(value, view, ec);
 }
diff --git a/include/ylt/thirdparty/iguana/define.h b/include/ylt/thirdparty/iguana/define.h
index 1f908fde6..ee0e35962 100644
--- a/include/ylt/thirdparty/iguana/define.h
+++ b/include/ylt/thirdparty/iguana/define.h
@@ -1,7 +1,9 @@
 #pragma once
 
 #include <array>
+#if __cplusplus >= 202002L
 #include <bit>
+#endif
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -36,11 +38,23 @@ template <typename T>
 constexpr inline bool contiguous_iterator = std::contiguous_iterator<T>;
 
 #else
-IGUANA_INLINE int countr_zero(unsigned long long x) {
+IGUANA_INLINE int countr_zero(unsigned long long n) {
   // x will never be zero in iguana
-  unsigned long pos;
-  _BitScanForward64(&pos, x);
-  return pos;
+#if defined(_MSC_VER) && defined(_M_X64)
+  unsigned long c;
+  _BitScanForward64(&c, n);
+  return static_cast<int>(c);
+#elif defined(_MSC_VER) && defined(_M_IX86)
+  unsigned long c;
+  if (static_cast<uint32_t>(n) != 0) {
+    _BitScanForward(&c, static_cast<uint32_t>(n));
+    return static_cast<int>(c);
+  }
+  else {
+    _BitScanForward(&c, static_cast<uint32_t>(n >> 32));
+    return static_cast<int>(c) + 32;
+  }
+#endif
 }
 
 namespace std {
diff --git a/include/ylt/thirdparty/iguana/enum_reflection.hpp b/include/ylt/thirdparty/iguana/enum_reflection.hpp
new file mode 100644
index 000000000..1e0d2ebe6
--- /dev/null
+++ b/include/ylt/thirdparty/iguana/enum_reflection.hpp
@@ -0,0 +1,172 @@
+#pragma once
+#include <array>
+#include <string_view>
+
+#include "frozen/string.h"
+#include "frozen/unordered_map.h"
+
+namespace iguana {
+template <typename T>
+constexpr std::string_view get_raw_name() {
+#ifdef _MSC_VER
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+template <auto T>
+constexpr std::string_view get_raw_name() {
+#ifdef _MSC_VER
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+template <typename T>
+inline constexpr std::string_view type_string() {
+  constexpr std::string_view sample = get_raw_name<int>();
+  constexpr size_t pos = sample.find("int");
+  constexpr std::string_view str = get_raw_name<T>();
+  constexpr auto next1 = str.rfind(sample[pos + 3]);
+#if defined(_MSC_VER)
+  constexpr auto s1 = str.substr(pos + 6, next1 - pos - 6);
+#else
+  constexpr auto s1 = str.substr(pos, next1 - pos);
+#endif
+  return s1;
+}
+
+template <auto T>
+inline constexpr std::string_view enum_string() {
+  constexpr std::string_view sample = get_raw_name<int>();
+  constexpr size_t pos = sample.find("int");
+  constexpr std::string_view str = get_raw_name<T>();
+  constexpr auto next1 = str.rfind(sample[pos + 3]);
+#if defined(__clang__) || defined(_MSC_VER)
+  constexpr auto s1 = str.substr(pos, next1 - pos);
+#else
+  constexpr auto s1 = str.substr(pos + 5, next1 - pos - 5);
+#endif
+  return s1;
+}
+
+#if defined(__clang__) && (__clang_major__ >= 17)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wenum-constexpr-conversion"
+#endif
+
+template <typename E, E V>
+constexpr std::string_view get_raw_name_with_v() {
+#ifdef _MSC_VER
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+// True means the V is a valid enum value, and the second of the result is the
+// name
+template <typename E, E V>
+constexpr std::pair<bool, std::string_view> try_get_enum_name() {
+  constexpr std::string_view sample_raw_name = get_raw_name_with_v<int, 5>();
+  constexpr size_t pos = sample_raw_name.find("5");
+  constexpr std::string_view enum_raw_name = get_raw_name_with_v<E, V>();
+  constexpr auto enum_end = enum_raw_name.rfind(&sample_raw_name[pos + 1]);
+#ifdef _MSC_VER
+  constexpr auto enum_begin = enum_raw_name.rfind(',', enum_end) + 1;
+#else
+  constexpr auto enum_begin = enum_raw_name.rfind(' ', enum_end) + 1;
+#endif
+  constexpr std::string_view res =
+      enum_raw_name.substr(enum_begin, enum_end - enum_begin);
+
+  constexpr size_t pos_brackets = res.find(')');
+
+  size_t pos_colon = res.find("::");
+  return {pos_brackets == std::string_view::npos,
+          res.substr(pos_colon == std::string_view::npos ? 0 : pos_colon + 2)};
+}
+
+// Enumerate the numbers in a integer sequence to see if they are legal enum
+// value
+template <typename E, std::int64_t... Is>
+constexpr inline auto get_enum_arr(
+    const std::integer_sequence<std::int64_t, Is...> &) {
+  constexpr std::size_t N = sizeof...(Is);
+  std::array<std::string_view, N> enum_names = {};
+  std::array<E, N> enum_values = {};
+  std::size_t num = 0;
+  (([&]() {
+     constexpr auto res = try_get_enum_name<E, static_cast<E>(Is)>();
+     if constexpr (res.first) {
+       //  the Is is a valid enum value
+       enum_names[num] = res.second;
+       enum_values[num] = static_cast<E>(Is);
+       ++num;
+     }
+   })(),
+   ...);
+  return std::make_tuple(num, enum_values, enum_names);
+}
+
+template <std::size_t N, const std::array<int, N> &arr, size_t... Is>
+constexpr auto array_to_seq(const std::index_sequence<Is...> &) {
+  return std::integer_sequence<std::int64_t, arr[Is]...>();
+}
+
+// convert array to map
+template <typename E, size_t N, size_t... Is>
+constexpr inline auto get_enum_to_str_map(
+    const std::array<std::string_view, N> &enum_names,
+    const std::array<E, N> &enum_values, const std::index_sequence<Is...> &) {
+  return frozen::unordered_map<E, frozen::string, sizeof...(Is)>{
+      {enum_values[Is], enum_names[Is]}...};
+}
+
+template <typename E, size_t N, size_t... Is>
+constexpr inline auto get_str_to_enum_map(
+    const std::array<std::string_view, N> &enum_names,
+    const std::array<E, N> &enum_values, const std::index_sequence<Is...> &) {
+  return frozen::unordered_map<frozen::string, E, sizeof...(Is)>{
+      {enum_names[Is], enum_values[Is]}...};
+}
+
+// the default generic enum_value
+// if the user has not defined a specialization template, this will be called
+template <typename T>
+struct enum_value {
+  constexpr static std::array<int, 0> value = {};
+};
+
+template <bool str_to_enum, typename E>
+constexpr inline auto get_enum_map() {
+  constexpr auto &arr = enum_value<E>::value;
+  constexpr auto arr_size = arr.size();
+  if constexpr (arr_size > 0) {
+    // the user has defined a specialization template
+    constexpr auto arr_seq =
+        array_to_seq<arr_size, arr>(std::make_index_sequence<arr_size>());
+    constexpr auto t = get_enum_arr<E>(arr_seq);
+    if constexpr (str_to_enum) {
+      return get_str_to_enum_map<E, arr_size>(
+          std::get<2>(t), std::get<1>(t),
+          std::make_index_sequence<std::get<0>(t)>{});
+    }
+    else {
+      return get_enum_to_str_map<E, arr_size>(
+          std::get<2>(t), std::get<1>(t),
+          std::make_index_sequence<std::get<0>(t)>{});
+    }
+  }
+  else {
+    return false;
+  }
+}
+
+#if defined(__clang__) && (__clang_major__ >= 17)
+#pragma clang diagnostic pop
+#endif
+
+}  // namespace iguana
\ No newline at end of file
diff --git a/include/ylt/thirdparty/iguana/json_reader.hpp b/include/ylt/thirdparty/iguana/json_reader.hpp
index 86831b027..16f34a802 100644
--- a/include/ylt/thirdparty/iguana/json_reader.hpp
+++ b/include/ylt/thirdparty/iguana/json_reader.hpp
@@ -25,7 +25,9 @@ IGUANA_INLINE void parse_escape(U &value, It &&it, It &&end) {
   if (*it == 'u') {
     ++it;
     if (std::distance(it, end) <= 4)
-      throw std::runtime_error(R"(Expected 4 hexadecimal digits)");
+      IGUANA_UNLIKELY {
+        throw std::runtime_error(R"(Expected 4 hexadecimal digits)");
+      }
     auto code_point = parse_unicode_hex4(it);
     encode_utf8(value, code_point);
   }
@@ -94,12 +96,6 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
       std::string_view(&*start, static_cast<size_t>(std::distance(start, it)));
 }
 
-template <typename U, typename It, std::enable_if_t<enum_v<U>, int> = 0>
-IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
-  using T = std::underlying_type_t<std::decay_t<U>>;
-  parse_item(reinterpret_cast<T &>(value), it, end);
-}
-
 template <bool skip = false, typename U, typename It,
           std::enable_if_t<char_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
@@ -197,7 +193,7 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
         IGUANA_UNLIKELY case '\\' : ++it;
         parse_escape(value, it, end);
         break;
-        IGUANA_UNLIKELY case ']' : return;
+        // IGUANA_UNLIKELY case ']' : return;
         IGUANA_UNLIKELY case '"' : ++it;
         return;
         IGUANA_LIKELY default : value.push_back(*it);
@@ -229,6 +225,27 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
   throw std::runtime_error("Expected \"");
 }
 
+template <typename U, typename It, std::enable_if_t<enum_v<U>, int> = 0>
+IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
+  static constexpr auto str_to_enum = get_enum_map<true, std::decay_t<U>>();
+  if constexpr (bool_v<decltype(str_to_enum)>) {
+    // not defined a specialization template
+    using T = std::underlying_type_t<std::decay_t<U>>;
+    parse_item(reinterpret_cast<T &>(value), it, end);
+  }
+  else {
+    std::string_view enum_names;
+    parse_item(enum_names, it, end);
+    auto it = str_to_enum.find(enum_names);
+    if (it != str_to_enum.end())
+      IGUANA_LIKELY { value = it->second; }
+    else {
+      throw std::runtime_error(std::string(enum_names) +
+                               " missing corresponding value in enum_value");
+    }
+  }
+}
+
 template <typename U, typename It, std::enable_if_t<fixed_array_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end) {
   using T = std::remove_reference_t<U>;
@@ -655,9 +672,8 @@ inline void parse_object(jobject &result, It &&it, It &&end) {
   skip_ws(it, end);
 
   while (true) {
-    if (it == end) {
-      break;
-    }
+    if (it == end)
+      IGUANA_UNLIKELY { throw std::runtime_error("Expected }"); }
     std::string key;
     detail::parse_item(key, it, end);
 
diff --git a/include/ylt/thirdparty/iguana/json_util.hpp b/include/ylt/thirdparty/iguana/json_util.hpp
index bd28f3333..986040efd 100644
--- a/include/ylt/thirdparty/iguana/json_util.hpp
+++ b/include/ylt/thirdparty/iguana/json_util.hpp
@@ -3,134 +3,11 @@
 
 #pragma once
 
-#include <math.h>
-
-#include <filesystem>
-#include <forward_list>
-#include <fstream>
-#include <optional>
-#include <stdexcept>
-#include <string_view>
-#include <type_traits>
-
-#include "define.h"
-#include "detail/charconv.h"
-#include "reflection.hpp"
+#include "util.hpp"
 #include "value.hpp"
 
 namespace iguana {
 
-template <typename T>
-inline constexpr bool char_v = std::is_same_v<std::decay_t<T>, char> ||
-                               std::is_same_v<std::decay_t<T>, char16_t> ||
-                               std::is_same_v<std::decay_t<T>, char32_t> ||
-                               std::is_same_v<std::decay_t<T>, wchar_t>;
-
-template <typename T>
-inline constexpr bool bool_v =
-    std::is_same_v<std::decay_t<T>, bool> ||
-    std::is_same_v<std::decay_t<T>, std::vector<bool>::reference>;
-
-template <typename T>
-inline constexpr bool int_v = std::is_integral_v<std::decay_t<T>> &&
-                              !char_v<std::decay_t<T>> && !bool_v<T>;
-
-template <typename T>
-inline constexpr bool float_v = std::is_floating_point_v<std::decay_t<T>>;
-
-template <typename T>
-inline constexpr bool num_v = float_v<T> || int_v<T>;
-
-template <typename T>
-inline constexpr bool enum_v = std::is_enum_v<std::decay_t<T>>;
-
-template <typename T>
-constexpr inline bool optional_v =
-    is_template_instant_of<std::optional, std::remove_cvref_t<T>>::value;
-
-template <class, class = void>
-struct is_container : std::false_type {};
-
-template <class T>
-struct is_container<
-    T, std::void_t<decltype(std::declval<T>().size(), std::declval<T>().begin(),
-                            std::declval<T>().end())>> : std::true_type {};
-
-template <class, class = void>
-struct is_map_container : std::false_type {};
-
-template <class T>
-struct is_map_container<
-    T, std::void_t<decltype(std::declval<typename T::mapped_type>())>>
-    : is_container<T> {};
-
-template <typename T>
-constexpr inline bool container_v = is_container<std::remove_cvref_t<T>>::value;
-
-template <typename T>
-constexpr inline bool map_container_v =
-    is_map_container<std::remove_cvref_t<T>>::value;
-
-template <class T>
-constexpr inline bool c_array_v = std::is_array_v<std::remove_cvref_t<T>> &&
-                                      std::extent_v<std::remove_cvref_t<T>> > 0;
-
-template <typename Type, typename = void>
-struct is_array : std::false_type {};
-
-template <typename T>
-struct is_array<
-    T, std::void_t<decltype(std::declval<T>().size()),
-                   typename std::enable_if_t<(std::tuple_size<T>::value != 0)>>>
-    : std::true_type {};
-
-template <typename T>
-constexpr inline bool array_v = is_array<std::remove_cvref_t<T>>::value;
-
-template <typename Type>
-constexpr inline bool fixed_array_v = c_array_v<Type> || array_v<Type>;
-
-template <typename T>
-constexpr inline bool string_view_v =
-    is_template_instant_of<std::basic_string_view,
-                           std::remove_cvref_t<T>>::value;
-
-template <typename T>
-constexpr inline bool string_v =
-    is_template_instant_of<std::basic_string, std::remove_cvref_t<T>>::value;
-
-// TODO: type must be char
-template <typename T>
-constexpr inline bool json_view_v = container_v<T>;
-
-template <typename T>
-constexpr inline bool json_byte_v =
-    std::is_same_v<char, std::remove_cvref_t<T>> ||
-    std::is_same_v<unsigned char, std::remove_cvref_t<T>> ||
-    std::is_same_v<std::byte, std::remove_cvref_t<T>>;
-
-template <typename T>
-constexpr inline bool sequence_container_v =
-    is_sequence_container<std::remove_cvref_t<T>>::value;
-
-template <typename T>
-constexpr inline bool tuple_v = is_tuple<std::remove_cvref_t<T>>::value;
-
-template <typename T>
-constexpr inline bool string_container_v = string_v<T> || string_view_v<T>;
-
-template <typename T>
-constexpr inline bool unique_ptr_v =
-    is_template_instant_of<std::unique_ptr, std::remove_cvref_t<T>>::value;
-
-template <class T>
-constexpr inline bool non_refletable_v =
-    container_v<T> || c_array_v<T> || tuple_v<T> || optional_v<T> ||
-    unique_ptr_v<T> || std::is_fundamental_v<std::remove_cvref_t<T>>;
-
-template <typename T>
-constexpr inline bool refletable_v = is_reflection_v<std::remove_cvref_t<T>>;
-
 class numeric_str {
  public:
   std::string_view &value() { return val_; }
@@ -138,15 +15,13 @@ class numeric_str {
   template <typename T>
   T convert() {
     static_assert(num_v<T>, "T must be numeric type");
-    if (val_.empty()) [[unlikely]] {
-      throw std::runtime_error("Failed to parse number");
-    }
+    if (val_.empty())
+      IGUANA_UNLIKELY { throw std::runtime_error("Failed to parse number"); }
     T res;
     auto [_, ec] =
         detail::from_chars(val_.data(), val_.data() + val_.size(), res);
-    if (ec != std::errc{}) [[unlikely]] {
-      throw std::runtime_error("Failed to parse number");
-    }
+    if (ec != std::errc{})
+      IGUANA_UNLIKELY { throw std::runtime_error("Failed to parse number"); }
     return res;
   }
 
@@ -158,39 +33,6 @@ template <typename T>
 constexpr inline bool numeric_str_v =
     std::is_same_v<numeric_str, std::remove_cvref_t<T>>;
 
-template <size_t N>
-struct string_literal {
-  static constexpr size_t size = (N > 0) ? (N - 1) : 0;
-
-  constexpr string_literal() = default;
-
-  constexpr string_literal(const char (&str)[N]) { std::copy_n(str, N, value); }
-
-  char value[N];
-  constexpr const char *end() const noexcept { return value + size; }
-
-  constexpr const std::string_view sv() const noexcept { return {value, size}; }
-};
-
-template <char... C, typename It>
-IGUANA_INLINE void match(It &&it, It &&end) {
-  const auto n = static_cast<size_t>(std::distance(it, end));
-  if (n < sizeof...(C))
-    IGUANA_UNLIKELY {
-      // TODO: compile time generate this message, currently borken with
-      // MSVC
-      static constexpr auto error = "Unexpected end of buffer. Expected:";
-      throw std::runtime_error(error);
-    }
-  if (((... || (*it++ != C))))
-    IGUANA_UNLIKELY {
-      // TODO: compile time generate this message, currently borken with
-      // MSVC
-      static constexpr char b[] = {C..., '\0'};
-      throw std::runtime_error(std::string("Expected these: ").append(b));
-    }
-}
-
 template <typename It>
 IGUANA_INLINE void skip_comment(It &&it, It &&end) {
   ++it;
diff --git a/include/ylt/thirdparty/iguana/json_writer.hpp b/include/ylt/thirdparty/iguana/json_writer.hpp
index 40f80de30..64758ece2 100644
--- a/include/ylt/thirdparty/iguana/json_writer.hpp
+++ b/include/ylt/thirdparty/iguana/json_writer.hpp
@@ -12,6 +12,13 @@ template <typename Stream, typename T,
           std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_json(T &&t, Stream &s);
 
+template <typename Stream, typename T>
+IGUANA_INLINE void render_json_value(Stream &ss, std::optional<T> &val);
+
+template <typename Stream, typename T,
+          std::enable_if_t<fixed_array_v<T>, int> = 0>
+IGUANA_INLINE void render_json_value(Stream &ss, const T &t);
+
 template <typename Stream, typename T,
           std::enable_if_t<sequence_container_v<T>, int> = 0>
 IGUANA_INLINE void render_json_value(Stream &ss, const T &v);
@@ -25,7 +32,10 @@ template <typename Stream, typename T,
 IGUANA_INLINE void render_json_value(Stream &ss, const T &o);
 
 template <typename Stream, typename T, std::enable_if_t<tuple_v<T>, int> = 0>
-IGUANA_INLINE void render_json_value(Stream &ss, const T &v);
+IGUANA_INLINE void render_json_value(Stream &s, T &&t);
+
+template <typename Stream, typename T, std::enable_if_t<variant_v<T>, int> = 0>
+IGUANA_INLINE void render_json_value(Stream &s, T &&t);
 
 template <typename Stream, typename InputIt, typename T, typename F>
 IGUANA_INLINE void join(Stream &ss, InputIt first, InputIt last, const T &delim,
@@ -99,7 +109,23 @@ IGUANA_INLINE void render_json_value(Stream &ss, T &&t) {
 
 template <typename Stream, typename T, std::enable_if_t<enum_v<T>, int> = 0>
 IGUANA_INLINE void render_json_value(Stream &ss, T val) {
-  render_json_value(ss, static_cast<std::underlying_type_t<T>>(val));
+  static constexpr auto enum_to_str = get_enum_map<false, std::decay_t<T>>();
+  if constexpr (bool_v<decltype(enum_to_str)>) {
+    render_json_value(ss, static_cast<std::underlying_type_t<T>>(val));
+  }
+  else {
+    auto it = enum_to_str.find(val);
+    if (it != enum_to_str.end())
+      IGUANA_LIKELY {
+        auto str = it->second;
+        render_json_value(ss, std::string_view(str.data(), str.size()));
+      }
+    else {
+      throw std::runtime_error(
+          std::to_string(static_cast<std::underlying_type_t<T>>(val)) +
+          " is a missing value in enum_value");
+    }
+  }
 }
 
 template <typename Stream, typename T>
@@ -122,8 +148,7 @@ IGUANA_INLINE void render_array(Stream &ss, const T &v) {
   ss.push_back(']');
 }
 
-template <typename Stream, typename T,
-          std::enable_if_t<fixed_array_v<T>, int> = 0>
+template <typename Stream, typename T, std::enable_if_t<fixed_array_v<T>, int>>
 IGUANA_INLINE void render_json_value(Stream &ss, const T &t) {
   if constexpr (std::is_same_v<char, std::remove_reference_t<
                                          decltype(std::declval<T>()[0])>>) {
@@ -188,7 +213,7 @@ IGUANA_INLINE void render_json_value(Stream &ss, const T &v) {
   }
 }
 
-template <typename Stream, typename T, std::enable_if_t<tuple_v<T>, int> = 0>
+template <typename Stream, typename T, std::enable_if_t<tuple_v<T>, int>>
 IGUANA_INLINE void render_json_value(Stream &s, T &&t) {
   using U = typename std::decay_t<T>;
   s.push_back('[');
@@ -203,6 +228,15 @@ IGUANA_INLINE void render_json_value(Stream &s, T &&t) {
   s.push_back(']');
 }
 
+template <typename Stream, typename T, std::enable_if_t<variant_v<T>, int>>
+IGUANA_INLINE void render_json_value(Stream &s, T &&t) {
+  std::visit(
+      [&s](auto value) {
+        render_json_value(s, value);
+      },
+      t);
+}
+
 template <typename Stream, typename T, std::enable_if_t<refletable_v<T>, int>>
 IGUANA_INLINE void to_json(T &&t, Stream &s) {
   s.push_back('{');
@@ -215,16 +249,9 @@ IGUANA_INLINE void to_json(T &&t, Stream &s) {
 
              write_json_key(s, i, t);
              s.push_back(':');
-
-             if constexpr (!is_reflection<decltype(v)>::value) {
-               render_json_value(s, t.*v);
-             }
-             else {
-               to_json(t.*v, s);
-             }
-
+             render_json_value(s, t.*v);
              if (Idx < Count - 1)
-               s.push_back(',');
+               IGUANA_LIKELY { s.push_back(','); }
            });
   s.push_back('}');
 }
diff --git a/include/ylt/thirdparty/iguana/util.hpp b/include/ylt/thirdparty/iguana/util.hpp
index b0850cbcb..79ebe8bf1 100644
--- a/include/ylt/thirdparty/iguana/util.hpp
+++ b/include/ylt/thirdparty/iguana/util.hpp
@@ -1,50 +1,166 @@
 #pragma once
+
+#include <math.h>
+
+#include <filesystem>
+#include <forward_list>
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <stdexcept>
 #include <string_view>
+#include <type_traits>
+
+#include "define.h"
+#include "detail/charconv.h"
+#include "enum_reflection.hpp"
+#include "error_code.h"
+#include "reflection.hpp"
 
 namespace iguana {
+
 template <typename T>
-constexpr std::string_view get_raw_name() {
-#ifdef _MSC_VER
-  return __FUNCSIG__;
-#else
-  return __PRETTY_FUNCTION__;
-#endif
-}
+inline constexpr bool char_v = std::is_same_v<std::decay_t<T>, char> ||
+                               std::is_same_v<std::decay_t<T>, char16_t> ||
+                               std::is_same_v<std::decay_t<T>, char32_t> ||
+                               std::is_same_v<std::decay_t<T>, wchar_t>;
 
-template <auto T>
-constexpr std::string_view get_raw_name() {
-#ifdef _MSC_VER
-  return __FUNCSIG__;
-#else
-  return __PRETTY_FUNCTION__;
-#endif
-}
+template <typename T>
+inline constexpr bool bool_v =
+    std::is_same_v<std::decay_t<T>, bool> ||
+    std::is_same_v<std::decay_t<T>, std::vector<bool>::reference>;
 
 template <typename T>
-inline constexpr std::string_view type_string() {
-  constexpr std::string_view sample = get_raw_name<int>();
-  constexpr size_t pos = sample.find("int");
-  constexpr std::string_view str = get_raw_name<T>();
-  constexpr auto next1 = str.rfind(sample[pos + 3]);
-#if defined(_MSC_VER)
-  constexpr auto s1 = str.substr(pos + 6, next1 - pos - 6);
-#else
-  constexpr auto s1 = str.substr(pos, next1 - pos);
-#endif
-  return s1;
-}
+inline constexpr bool int_v = std::is_integral_v<std::decay_t<T>> &&
+                              !char_v<std::decay_t<T>> && !bool_v<T>;
+
+template <typename T>
+inline constexpr bool float_v = std::is_floating_point_v<std::decay_t<T>>;
+
+template <typename T>
+inline constexpr bool num_v = float_v<T> || int_v<T>;
+
+template <typename T>
+inline constexpr bool enum_v = std::is_enum_v<std::decay_t<T>>;
+
+template <typename T>
+constexpr inline bool optional_v =
+    is_template_instant_of<std::optional, std::remove_cvref_t<T>>::value;
+
+template <class, class = void>
+struct is_container : std::false_type {};
+
+template <class T>
+struct is_container<
+    T, std::void_t<decltype(std::declval<T>().size(), std::declval<T>().begin(),
+                            std::declval<T>().end())>> : std::true_type {};
+
+template <class, class = void>
+struct is_map_container : std::false_type {};
+
+template <class T>
+struct is_map_container<
+    T, std::void_t<decltype(std::declval<typename T::mapped_type>())>>
+    : is_container<T> {};
+
+template <typename T>
+constexpr inline bool container_v = is_container<std::remove_cvref_t<T>>::value;
+
+template <typename T>
+constexpr inline bool map_container_v =
+    is_map_container<std::remove_cvref_t<T>>::value;
+
+template <class T>
+constexpr inline bool c_array_v = std::is_array_v<std::remove_cvref_t<T>> &&
+                                      std::extent_v<std::remove_cvref_t<T>> > 0;
+
+template <typename Type, typename = void>
+struct is_array : std::false_type {};
+
+template <typename T>
+struct is_array<
+    T, std::void_t<decltype(std::declval<T>().size()),
+                   typename std::enable_if_t<(std::tuple_size<T>::value != 0)>>>
+    : std::true_type {};
+
+template <typename T>
+constexpr inline bool array_v = is_array<std::remove_cvref_t<T>>::value;
+
+template <typename Type>
+constexpr inline bool fixed_array_v = c_array_v<Type> || array_v<Type>;
+
+template <typename T>
+constexpr inline bool string_view_v =
+    is_template_instant_of<std::basic_string_view,
+                           std::remove_cvref_t<T>>::value;
+
+template <typename T>
+constexpr inline bool string_v =
+    is_template_instant_of<std::basic_string, std::remove_cvref_t<T>>::value;
+
+// TODO: type must be char
+template <typename T>
+constexpr inline bool json_view_v = container_v<T>;
 
-template <auto T>
-inline constexpr std::string_view enum_string() {
-  constexpr std::string_view sample = get_raw_name<int>();
-  constexpr size_t pos = sample.find("int");
-  constexpr std::string_view str = get_raw_name<T>();
-  constexpr auto next1 = str.rfind(sample[pos + 3]);
-#if defined(__clang__) || defined(_MSC_VER)
-  constexpr auto s1 = str.substr(pos, next1 - pos);
-#else
-  constexpr auto s1 = str.substr(pos + 5, next1 - pos - 5);
-#endif
-  return s1;
+template <typename T>
+constexpr inline bool json_byte_v =
+    std::is_same_v<char, std::remove_cvref_t<T>> ||
+    std::is_same_v<unsigned char, std::remove_cvref_t<T>> ||
+    std::is_same_v<std::byte, std::remove_cvref_t<T>>;
+
+template <typename T>
+constexpr inline bool sequence_container_v =
+    is_sequence_container<std::remove_cvref_t<T>>::value;
+
+template <typename T>
+constexpr inline bool tuple_v = is_tuple<std::remove_cvref_t<T>>::value;
+
+template <typename T>
+constexpr inline bool string_container_v = string_v<T> || string_view_v<T>;
+
+template <typename T>
+constexpr inline bool unique_ptr_v =
+    is_template_instant_of<std::unique_ptr, std::remove_cvref_t<T>>::value;
+
+template <typename T>
+struct is_variant : std::false_type {};
+
+template <typename... T>
+struct is_variant<std::variant<T...>> : std::true_type {};
+
+template <typename T>
+constexpr inline bool variant_v = is_variant<std::remove_cvref_t<T>>::value;
+
+template <class T>
+constexpr inline bool non_refletable_v =
+    container_v<T> || c_array_v<T> || tuple_v<T> || optional_v<T> ||
+    unique_ptr_v<T> || std::is_fundamental_v<std::remove_cvref_t<T>> ||
+    variant_v<T>;
+
+template <typename T>
+constexpr inline bool refletable_v = is_reflection_v<std::remove_cvref_t<T>>;
+
+template <typename T>
+constexpr inline bool plain_v =
+    string_container_v<T> || num_v<T> || char_v<T> || bool_v<T> || enum_v<T>;
+
+template <char... C, typename It>
+IGUANA_INLINE void match(It &&it, It &&end) {
+  const auto n = static_cast<size_t>(std::distance(it, end));
+  if (n < sizeof...(C))
+    IGUANA_UNLIKELY {
+      // TODO: compile time generate this message, currently borken with
+      // MSVC
+      static constexpr auto error = "Unexpected end of buffer. Expected:";
+      throw std::runtime_error(error);
+    }
+  if (((... || (*it++ != C))))
+    IGUANA_UNLIKELY {
+      // TODO: compile time generate this message, currently borken with
+      // MSVC
+      static constexpr char b[] = {C..., '\0'};
+      throw std::runtime_error(std::string("Expected these: ").append(b));
+    }
 }
-}  // namespace iguana
\ No newline at end of file
+
+}  // namespace iguana
diff --git a/include/ylt/thirdparty/iguana/xml_reader.hpp b/include/ylt/thirdparty/iguana/xml_reader.hpp
index b4477d09a..f6cae0be0 100644
--- a/include/ylt/thirdparty/iguana/xml_reader.hpp
+++ b/include/ylt/thirdparty/iguana/xml_reader.hpp
@@ -8,34 +8,42 @@
 namespace iguana {
 namespace detail {
 
-template <refletable T, typename It>
-IGUANA_INLINE void parse_item(T &value, It &&it, It &&end,
+template <typename U, typename It, std::enable_if_t<optional_v<U>, int> = 0>
+IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
+                              std::string_view name);
+
+template <typename U, typename It, std::enable_if_t<unique_ptr_v<U>, int> = 0>
+IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
+                              std::string_view name);
+
+template <typename U, typename It, std::enable_if_t<refletable_v<U>, int> = 0>
+IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name);
 
-template <attr_t U, typename It>
+template <typename U, typename It, std::enable_if_t<attr_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name);
 
-template <plain_t U, typename It>
+template <typename U, typename It, std::enable_if_t<plain_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &&value, It &&begin, It &&end) {
   using T = std::decay_t<U>;
-  if constexpr (string_t<T>) {
+  if constexpr (string_container_v<T>) {
     value = T(&*begin, static_cast<size_t>(std::distance(begin, end)));
   }
-  else if constexpr (num_t<T>) {
+  else if constexpr (num_v<T>) {
     auto size = std::distance(begin, end);
     const auto start = &*begin;
     auto [p, ec] = detail::from_chars(start, start + size, value);
-    if (ec != std::errc{}) [[unlikely]]
-      throw std::runtime_error("Failed to parse number");
+    if (ec != std::errc{})
+      IGUANA_UNLIKELY
+    throw std::runtime_error("Failed to parse number");
   }
-  else if constexpr (char_t<T>) {
-    if (static_cast<size_t>(std::distance(begin, end)) != 1) [[unlikely]] {
-      throw std::runtime_error("Expected one character");
-    }
+  else if constexpr (char_v<T>) {
+    if (static_cast<size_t>(std::distance(begin, end)) != 1)
+      IGUANA_UNLIKELY { throw std::runtime_error("Expected one character"); }
     value = *begin;
   }
-  else if constexpr (bool_t<T>) {
+  else if constexpr (bool_v<T>) {
     auto bool_v = std::string_view(
         &*begin, static_cast<size_t>(std::distance(begin, end)));
     if (bool_v == "true") {
@@ -44,25 +52,38 @@ IGUANA_INLINE void parse_value(U &&value, It &&begin, It &&end) {
     else if (bool_v == "false") {
       value = false;
     }
-    else [[unlikely]] {
-      throw std::runtime_error("Expected true or false");
-    }
+    else
+      IGUANA_UNLIKELY { throw std::runtime_error("Expected true or false"); }
   }
-  else if constexpr (enum_t<T>) {
-    using T = std::underlying_type_t<std::decay_t<U>>;
-    parse_value(reinterpret_cast<T &>(value), begin, end);
+  else if constexpr (enum_v<T>) {
+    static constexpr auto str_to_enum = get_enum_map<true, T>();
+    if constexpr (bool_v<decltype(str_to_enum)>) {
+      // not defined a specialization template
+      parse_value(reinterpret_cast<std::underlying_type_t<T> &>(value), begin,
+                  end);
+    }
+    else {
+      auto enum_names = std::string_view(
+          &*begin, static_cast<size_t>(std::distance(begin, end)));
+      auto it = str_to_enum.find(enum_names);
+      if (it != str_to_enum.end())
+        IGUANA_LIKELY { value = it->second; }
+      else {
+        throw std::runtime_error(std::string(enum_names) +
+                                 " missing corresponding value in enum_value");
+      }
+    }
   }
 }
-
-template <map_container U, typename It>
+template <typename U, typename It,
+          std::enable_if_t<map_container_v<U>, int> = 0>
 IGUANA_INLINE void parse_attr(U &&value, It &&it, It &&end) {
   using key_type = typename std::remove_cvref_t<U>::key_type;
   using value_type = typename std::remove_cvref_t<U>::mapped_type;
   while (it != end) {
     skip_sapces_and_newline(it, end);
-    if (*it == '>' || *it == '/') [[unlikely]] {
-      return;
-    }
+    if (*it == '>' || *it == '/')
+      IGUANA_UNLIKELY { return; }
     auto key_begin = it;
     auto key_end = skip_pass<'='>(it, end);
     key_type key;
@@ -78,7 +99,7 @@ IGUANA_INLINE void parse_attr(U &&value, It &&it, It &&end) {
   }
 }
 
-template <plain_t U, typename It>
+template <typename U, typename It, std::enable_if_t<plain_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name) {
   skip_till<'>'>(it, end);
@@ -90,50 +111,54 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
   match_close_tag(it, end, name);
 }
 
-template <sequence_container_t U, typename It>
+template <typename U, typename It,
+          std::enable_if_t<sequence_container_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name) {
   parse_item(value.emplace_back(), it, end, name);
   skip_sapces_and_newline(it, end);
   while (it != end) {
     match<'<'>(it, end);
-    if (*it == '?' || *it == '!') [[unlikely]] {
-      // skip <?
-      if (*(it + 1) == '[') {
-        --it;
-        return;
-      }
-      else {
-        skip_till<'>'>(it, end);
-        ++it;
-        skip_sapces_and_newline(it, end);
-        continue;
+    if (*it == '?' || *it == '!')
+      IGUANA_UNLIKELY {
+        // skip <?
+        if (*(it + 1) == '[') {
+          --it;
+          return;
+        }
+        else {
+          skip_till<'>'>(it, end);
+          ++it;
+          skip_sapces_and_newline(it, end);
+          continue;
+        }
       }
-    }
     auto start = it;
     skip_till_greater_or_space(it, end);
     std::string_view key = std::string_view{
         &*start, static_cast<size_t>(std::distance(start, it))};
-    if (key != name) [[unlikely]] {
-      it = start - 1;
-      return;
-    }
+    if (key != name)
+      IGUANA_UNLIKELY {
+        it = start - 1;
+        return;
+      }
     parse_item(value.emplace_back(), it, end, name);
     skip_sapces_and_newline(it, end);
   }
 }
 
-template <optional_t U, typename It>
+template <typename U, typename It, std::enable_if_t<optional_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name) {
   using value_type = typename std::remove_reference_t<U>::value_type;
   skip_till<'>'>(it, end);
-  if (*(it - 1) == '/') [[likely]] {
-    ++it;
-    return;
-  }
+  if (*(it - 1) == '/')
+    IGUANA_LIKELY {
+      ++it;
+      return;
+    }
 
-  if constexpr (plain_t<value_type>) {
+  if constexpr (plain_v<value_type>) {
     // The following code is for option not to be emplaced
     // when parse  "...> <..."
     skip_till<'>'>(it, end);
@@ -153,14 +178,14 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
   }
 }
 
-template <unique_ptr_t U, typename It>
+template <typename U, typename It, std::enable_if_t<unique_ptr_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name) {
   value = std::make_unique<typename std::remove_cvref_t<U>::element_type>();
   parse_item(*value, it, end, name);
 }
 
-template <attr_t U, typename It>
+template <typename U, typename It, std::enable_if_t<attr_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end,
                               std::string_view name) {
   parse_attr(value.attr(), it, end);
@@ -193,65 +218,69 @@ IGUANA_INLINE void skip_object_value(It &&it, It &&end, std::string_view name) {
 }
 
 // return true means reach the close tag
-template <size_t cdata_idx, refletable T, typename It>
+template <size_t cdata_idx, typename T, typename It,
+          std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE auto skip_till_key(T &value, It &&it, It &&end) {
   skip_sapces_and_newline(it, end);
   while (true) {
     match<'<'>(it, end);
-    if (*it == '/') [[unlikely]] {
-      // </tag>
-      return true;  // reach the close tag
-    }
-    else if (*it == '?') [[unlikely]] {
-      // <? ... ?>
-      skip_till<'>'>(it, end);
-      ++it;
-      skip_sapces_and_newline(it, end);
-      continue;
-    }
-    else if (*it == '!') [[unlikely]] {
-      ++it;
-      if (*it == '[') {
-        // <![
-        if constexpr (cdata_idx == iguana::get_value<std::decay_t<T>>()) {
-          ++it;
-          skip_till<']'>(it, end);
-          ++it;
-          match<"]>">(it, end);
-          skip_sapces_and_newline(it, end);
-          continue;
-        }
-        else {
-          // if parse cdata
-          ++it;
-          match<"CDATA[">(it, end);
-          skip_sapces_and_newline(it, end);
-          auto &cdata_value = get<cdata_idx>(value);
-          using VT = typename std::decay_t<decltype(cdata_value)>::value_type;
-          auto vb = it;
-          auto ve = skip_pass<']'>(it, end);
-          if constexpr (str_view_t<VT>) {
-            cdata_value.value() =
-                VT(&*vb, static_cast<size_t>(std::distance(vb, ve)));
+    if (*it == '/')
+      IGUANA_UNLIKELY {
+        // </tag>
+        return true;  // reach the close tag
+      }
+    else if (*it == '?')
+      IGUANA_UNLIKELY {
+        // <? ... ?>
+        skip_till<'>'>(it, end);
+        ++it;
+        skip_sapces_and_newline(it, end);
+        continue;
+      }
+    else if (*it == '!')
+      IGUANA_UNLIKELY {
+        ++it;
+        if (*it == '[') {
+          // <![
+          if constexpr (cdata_idx == iguana::get_value<std::decay_t<T>>()) {
+            ++it;
+            skip_till<']'>(it, end);
+            ++it;
+            match<']', '>'>(it, end);
+            skip_sapces_and_newline(it, end);
+            continue;
           }
           else {
-            cdata_value.value().append(
-                &*vb, static_cast<size_t>(std::distance(vb, ve)));
+            // if parse cdata
+            ++it;
+            match<'C', 'D', 'A', 'T', 'A', '['>(it, end);
+            skip_sapces_and_newline(it, end);
+            auto &cdata_value = get<cdata_idx>(value);
+            using VT = typename std::decay_t<decltype(cdata_value)>::value_type;
+            auto vb = it;
+            auto ve = skip_pass<']'>(it, end);
+            if constexpr (string_view_v<VT>) {
+              cdata_value.value() =
+                  VT(&*vb, static_cast<size_t>(std::distance(vb, ve)));
+            }
+            else {
+              cdata_value.value().append(
+                  &*vb, static_cast<size_t>(std::distance(vb, ve)));
+            }
+            match<']', '>'>(it, end);
+            skip_sapces_and_newline(it, end);
+            continue;
           }
-          match<"]>">(it, end);
+        }
+        else {
+          // <!-- -->
+          // <!D
+          skip_till<'>'>(it, end);
+          ++it;
           skip_sapces_and_newline(it, end);
           continue;
         }
       }
-      else {
-        // <!-- -->
-        // <!D
-        skip_till<'>'>(it, end);
-        ++it;
-        skip_sapces_and_newline(it, end);
-        continue;
-      }
-    }
     return false;
   }
 }
@@ -271,7 +300,7 @@ IGUANA_INLINE void check_required(std::string_view key_set) {
   }
 }
 
-template <refletable T, typename It>
+template <typename T, typename It, std::enable_if_t<refletable_v<T>, int>>
 IGUANA_INLINE void parse_item(T &value, It &&it, It &&end,
                               std::string_view name) {
   using U = std::decay_t<T>;
@@ -291,62 +320,69 @@ IGUANA_INLINE void parse_item(T &value, It &&it, It &&end,
   bool parse_done = false;
   // sequential parse
   for_each(value, [&](const auto member_ptr, auto i) IGUANA__INLINE_LAMBDA {
+#if defined(_MSC_VER) && _MSVC_LANG < 202002L
+    // seems MVSC can't pass a constexpr value to lambda
+    constexpr auto cdata_idx = get_type_index<is_cdata_t, U>();
+#endif
     using item_type = std::remove_reference_t<decltype(value.*member_ptr)>;
     constexpr auto mkey = iguana::get_name<T, decltype(i)::value>();
     constexpr std::string_view st_key(mkey.data(), mkey.size());
-    if constexpr (cdata_t<item_type>) {
-      return;
-    }
-    if (parse_done || key != st_key) [[unlikely]] {
+    if constexpr (cdata_v<item_type>) {
       return;
     }
-    if constexpr (!cdata_t<item_type>) {
+    if (parse_done || key != st_key)
+      IGUANA_UNLIKELY { return; }
+    if constexpr (!cdata_v<item_type>) {
       parse_item(value.*member_ptr, it, end, key);
       if constexpr (iguana::has_iguana_required_arr_v<U>) {
         key_set.append(key).append(", ");
       }
     }
-    if (skip_till_key<cdata_idx>(value, it, end)) [[unlikely]] {
-      match_close_tag(it, end, name);
-      parse_done = true;
-      return;
-    }
+    if (skip_till_key<cdata_idx>(value, it, end))
+      IGUANA_UNLIKELY {
+        match_close_tag(it, end, name);
+        parse_done = true;
+        return;
+      }
     start = it;
     skip_till_greater_or_space(it, end);
     key = std::string_view{&*start,
                            static_cast<size_t>(std::distance(start, it))};
   });
-  if (parse_done) [[unlikely]] {
-    check_required<U>(key_set);
-    return;
-  }
+  if (parse_done)
+    IGUANA_UNLIKELY {
+      check_required<U>(key_set);
+      return;
+    }
   // map parse
   while (true) {
     static constexpr auto frozen_map = get_iguana_struct_map<T>();
     const auto &member_it = frozen_map.find(key);
-    if (member_it != frozen_map.end()) [[likely]] {
-      std::visit(
-          [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
-            static_assert(
-                std::is_member_pointer_v<std::decay_t<decltype(member_ptr)>>,
-                "type must be memberptr");
-            using V = std::remove_reference_t<decltype(value.*member_ptr)>;
-            if constexpr (!cdata_t<V>) {
-              parse_item(value.*member_ptr, it, end, key);
-              if constexpr (iguana::has_iguana_required_arr_v<U>) {
-                key_set.append(key).append(", ");
+    if (member_it != frozen_map.end())
+      IGUANA_LIKELY {
+        std::visit(
+            [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
+              static_assert(
+                  std::is_member_pointer_v<std::decay_t<decltype(member_ptr)>>,
+                  "type must be memberptr");
+              using V = std::remove_reference_t<decltype(value.*member_ptr)>;
+              if constexpr (!cdata_v<V>) {
+                parse_item(value.*member_ptr, it, end, key);
+                if constexpr (iguana::has_iguana_required_arr_v<U>) {
+                  key_set.append(key).append(", ");
+                }
               }
-            }
-          },
-          member_it->second);
-    }
-    else [[unlikely]] {
+            },
+            member_it->second);
+      }
+    else
+      IGUANA_UNLIKELY {
 #ifdef THROW_UNKNOWN_KEY
-      throw std::runtime_error("Unknown key: " + std::string(key));
+        throw std::runtime_error("Unknown key: " + std::string(key));
 #else
-      skip_object_value(it, end, key);
+        skip_object_value(it, end, key);
 #endif
-    }
+      }
     if (skip_till_key<cdata_idx>(value, it, end)) {
       match_close_tag(it, end, name);
       check_required<U>(key_set);
@@ -361,7 +397,7 @@ IGUANA_INLINE void parse_item(T &value, It &&it, It &&end,
 
 }  // namespace detail
 
-template <attr_t U, typename It>
+template <typename It, typename U, std::enable_if_t<attr_v<U>, int> = 0>
 IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   while (it != end) {
     skip_sapces_and_newline(it, end);
@@ -381,7 +417,8 @@ IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   detail::parse_attr(value.attr(), it, end);
   detail::parse_item(value.value(), it, end, key);
 }
-template <refletable U, typename It>
+
+template <typename It, typename U, std::enable_if_t<refletable_v<U>, int> = 0>
 IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   while (it != end) {
     skip_sapces_and_newline(it, end);
@@ -401,12 +438,12 @@ IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   detail::parse_item(value, it, end, key);
 }
 
-template <typename U, string_t View>
+template <typename U, typename View, std::enable_if_t<string_v<View>, int> = 0>
 IGUANA_INLINE void from_xml(U &value, const View &view) {
   from_xml(value, std::begin(view), std::end(view));
 }
 
-template <num_t Num>
+template <typename Num, std::enable_if_t<num_v<Num>, int> = 0>
 IGUANA_INLINE Num get_number(std::string_view str) {
   Num num;
   detail::parse_value(num, str.begin(), str.end());
diff --git a/include/ylt/thirdparty/iguana/xml_util.hpp b/include/ylt/thirdparty/iguana/xml_util.hpp
index 5b92af28b..be28c4d27 100644
--- a/include/ylt/thirdparty/iguana/xml_util.hpp
+++ b/include/ylt/thirdparty/iguana/xml_util.hpp
@@ -1,123 +1,7 @@
 #pragma once
-
-#include <math.h>
-
-#include <bit>
-#include <filesystem>
-#include <forward_list>
-#include <fstream>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string_view>
-#include <type_traits>
-
-#include "define.h"
-#include "reflection.hpp"
+#include "util.hpp"
 
 namespace iguana {
-
-template <class T>
-concept char_t = std::same_as < std::decay_t<T>,
-char > || std::same_as<std::decay_t<T>, char16_t> ||
-    std::same_as<std::decay_t<T>, char32_t> ||
-    std::same_as<std::decay_t<T>, wchar_t>;
-
-template <class T>
-concept bool_t = std::same_as < std::decay_t<T>,
-bool > || std::same_as<std::decay_t<T>, std::vector<bool>::reference>;
-
-template <class T>
-concept int_t =
-    std::integral<std::decay_t<T>> && !char_t<std::decay_t<T>> && !bool_t<T>;
-
-template <class T>
-concept float_t = std::floating_point<std::decay_t<T>>;
-
-template <class T>
-concept num_t = std::floating_point<std::decay_t<T>> || int_t<T>;
-
-template <class T>
-concept enum_t = std::is_enum_v<std::decay_t<T>>;
-
-template <typename T>
-constexpr inline bool is_basic_string_view = false;
-
-template <typename T>
-constexpr inline bool is_basic_string_view<std::basic_string_view<T>> = true;
-
-template <typename T>
-concept str_view_t = is_basic_string_view<std::remove_reference_t<T>>;
-
-template <class T>
-concept str_t =
-    std::convertible_to<std::decay_t<T>, std::string_view> && !str_view_t<T>;
-
-template <class T>
-concept string_t = std::convertible_to<std::decay_t<T>, std::string_view>;
-
-template <class T>
-concept tuple_t = is_tuple<std::remove_cvref_t<T>>::value;
-
-template <class T>
-concept sequence_container_t =
-    is_sequence_container<std::remove_cvref_t<T>>::value;
-
-template <typename T>
-concept refletable = is_reflection_v<std::remove_cvref_t<T>>;
-
-template <typename Type>
-concept unique_ptr_t = requires(Type ptr) {
-  ptr.operator*();
-  typename std::remove_cvref_t<Type>::element_type;
-}
-&&!requires(Type ptr, Type ptr2) { ptr = ptr2; };
-
-template <typename Type>
-concept optional_t = requires(Type optional) {
-  optional.value();
-  optional.has_value();
-  optional.operator*();
-  typename std::remove_cvref_t<Type>::value_type;
-};
-
-template <typename Type>
-concept container = requires(Type container) {
-  typename std::remove_cvref_t<Type>::value_type;
-  container.size();
-  container.begin();
-  container.end();
-};
-template <typename Type>
-concept map_container = container<Type> && requires(Type container) {
-  typename std::remove_cvref_t<Type>::mapped_type;
-};
-
-template <class T>
-concept plain_t =
-    string_t<T> || num_t<T> || char_t<T> || bool_t<T> || enum_t<T>;
-
-template <class T>
-concept c_array = std::is_array_v<std::remove_cvref_t<T>> &&
-                  std::extent_v<std::remove_cvref_t<T>> >
-0;
-
-template <typename Type>
-concept array = requires(Type arr) {
-  arr.size();
-  std::tuple_size<std::remove_cvref_t<Type>>{};
-};
-
-template <typename Type>
-concept tuple = !array<Type> && requires(Type tuple) {
-  std::get<0>(tuple);
-  sizeof(std::tuple_size<std::remove_cvref_t<Type>>);
-};
-
-template <class T>
-concept non_refletable = container<T> || c_array<T> || tuple<T> ||
-    optional_t<T> || unique_ptr_t<T> || std::is_fundamental_v<T>;
-
 template <typename T, typename map_type = std::unordered_map<std::string_view,
                                                              std::string_view>>
 class xml_attr_t {
@@ -133,7 +17,8 @@ class xml_attr_t {
   map_type attr_;
 };
 
-template <string_t T = std::string_view>
+template <typename T = std::string_view,
+          std::enable_if_t<string_container_v<T>, int> = 0>
 class xml_cdata_t {
  public:
   T &value() { return val_; }
@@ -151,7 +36,7 @@ template <typename T, typename map_type>
 constexpr inline bool is_attr_t_v<xml_attr_t<T, map_type>> = true;
 
 template <typename T>
-concept attr_t = is_attr_t_v<std::decay_t<T>>;
+constexpr inline bool attr_v = is_attr_t_v<std::remove_cvref_t<T>>;
 
 template <typename>
 struct is_cdata_t : std::false_type {};
@@ -160,21 +45,7 @@ template <typename T>
 struct is_cdata_t<xml_cdata_t<T>> : std::true_type {};
 
 template <typename T>
-concept cdata_t = is_cdata_t<std::decay_t<T>>::value;
-
-template <size_t N>
-struct string_literal {
-  static constexpr size_t size = (N > 0) ? (N - 1) : 0;
-
-  constexpr string_literal() = default;
-
-  constexpr string_literal(const char (&str)[N]) { std::copy_n(str, N, value); }
-
-  char value[N];
-  constexpr const char *end() const noexcept { return value + size; }
-
-  constexpr const std::string_view sv() const noexcept { return {value, size}; }
-};
+constexpr inline bool cdata_v = is_cdata_t<std::remove_cvref_t<T>>::value;
 
 inline constexpr auto has_zero = [](uint64_t chunk) IGUANA__INLINE_LAMBDA {
   return (((chunk - 0x0101010101010101) & ~chunk) & 0x8080808080808080);
@@ -217,57 +88,25 @@ inline constexpr auto has_qoute = [](uint64_t chunk) IGUANA__INLINE_LAMBDA {
       0b0010001000100010001000100010001000100010001000100010001000100010);
 };
 
-IGUANA_INLINE void skip_sapces_and_newline(auto &&it, auto &&end) {
+template <typename It>
+IGUANA_INLINE void skip_sapces_and_newline(It &&it, It &&end) {
   while (it != end && (*it < 33)) {
     ++it;
   }
 }
 
-// match c and skip
-template <char c>
-IGUANA_INLINE void match(auto &&it, auto &&end) {
-  if (it == end || *it != c) [[unlikely]] {
-    static constexpr char b[] = {c, '\0'};
-    std::string error = std::string("Expected:").append(b);
-    throw std::runtime_error(error);
-  }
-  else [[likely]] {
-    ++it;
-  }
-}
-
-template <string_literal str>
-IGUANA_INLINE void match(auto &&it, auto &&end) {
-  const auto n = static_cast<size_t>(std::distance(it, end));
-  if (n < str.size) [[unlikely]] {
-    // TODO: compile time generate this message, currently borken with
-    // MSVC
-    static constexpr auto error = "Unexpected end of buffer. Expected:";
-    throw std::runtime_error(error);
-  }
-  size_t i{};
-  // clang and gcc will vectorize this loop
-  for (auto *c = str.value; c < str.end(); ++it, ++c) {
-    i += *it != *c;
-  }
-  if (i != 0) [[unlikely]] {
-    // TODO: compile time generate this message, currently borken with
-    // MSVC
-    static constexpr auto error = "Expected: ";
-    throw std::runtime_error(error);
-  }
-}
-
-IGUANA_INLINE void match_close_tag(auto &&it, auto &&end,
-                                   std::string_view key) {
-  if (it == end || (*it++) != '/') [[unlikely]] {
-    throw std::runtime_error("unclosed tag: " + std::string(key));
-  }
+template <typename It>
+IGUANA_INLINE void match_close_tag(It &&it, It &&end, std::string_view key) {
+  if (it == end || (*it++) != '/')
+    IGUANA_UNLIKELY {
+      throw std::runtime_error("unclosed tag: " + std::string(key));
+    }
   size_t size = key.size();
   if (static_cast<size_t>(std::distance(it, end)) <= size ||
-      std::string_view{&*it, size} != key) [[unlikely]] {
-    throw std::runtime_error("unclosed tag: " + std::string(key));
-  }
+      std::string_view{&*it, size} != key)
+    IGUANA_UNLIKELY {
+      throw std::runtime_error("unclosed tag: " + std::string(key));
+    }
   it += size;
   match<'>'>(it, end);
 
@@ -275,35 +114,36 @@ IGUANA_INLINE void match_close_tag(auto &&it, auto &&end,
   // ++it;
 }
 
-template <char c>
-IGUANA_INLINE void skip_till(auto &&it, auto &&end) {
-  static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
-
-  if (std::distance(it, end) >= 7) [[likely]] {
-    const auto end_m7 = end - 7;
-    for (; it < end_m7; it += 8) {
-      const auto chunk = *reinterpret_cast<const uint64_t *>(&*it);
-      uint64_t test;
-      if constexpr (c == '>')
-        test = has_greater(chunk);
-      else if constexpr (c == '<')
-        test = has_smaller(chunk);
-      else if constexpr (c == '"')
-        test = has_qoute(chunk);
-      else if constexpr (c == ' ')
-        test = has_space(chunk);
-      else if constexpr (c == ']')
-        test = has_square_bracket(chunk);
-      else if constexpr (c == '=')
-        test = has_equal(chunk);
-      else
-        static_assert(!c, "not support this character");
-      if (test != 0) {
-        it += (std::countr_zero(test) >> 3);
-        return;
+template <char c, typename It>
+IGUANA_INLINE void skip_till(It &&it, It &&end) {
+  static_assert(contiguous_iterator<std::decay_t<It>>);
+
+  if (std::distance(it, end) >= 7)
+    IGUANA_LIKELY {
+      const auto end_m7 = end - 7;
+      for (; it < end_m7; it += 8) {
+        const auto chunk = *reinterpret_cast<const uint64_t *>(&*it);
+        uint64_t test;
+        if constexpr (c == '>')
+          test = has_greater(chunk);
+        else if constexpr (c == '<')
+          test = has_smaller(chunk);
+        else if constexpr (c == '"')
+          test = has_qoute(chunk);
+        else if constexpr (c == ' ')
+          test = has_space(chunk);
+        else if constexpr (c == ']')
+          test = has_square_bracket(chunk);
+        else if constexpr (c == '=')
+          test = has_equal(chunk);
+        else
+          static_assert(!c, "not support this character");
+        if (test != 0) {
+          it += (countr_zero(test) >> 3);
+          return;
+        }
       }
     }
-  }
 
   // Tail end of buffer. Should be rare we even get here
   while (it < end) {
@@ -317,20 +157,22 @@ IGUANA_INLINE void skip_till(auto &&it, auto &&end) {
 }
 
 // skip_till<'>', '<'>(it, end);
-IGUANA_INLINE void skip_till_greater_or_space(auto &&it, auto &&end) {
-  static_assert(std::contiguous_iterator<std::decay_t<decltype(it)>>);
-
-  if (std::distance(it, end) >= 7) [[likely]] {
-    const auto end_m7 = end - 7;
-    for (; it < end_m7; it += 8) {
-      const auto chunk = *reinterpret_cast<const uint64_t *>(&*it);
-      uint64_t test = has_greater(chunk) | has_space(chunk);
-      if (test != 0) {
-        it += (std::countr_zero(test) >> 3);
-        return;
+template <typename It>
+IGUANA_INLINE void skip_till_greater_or_space(It &&it, It &&end) {
+  static_assert(contiguous_iterator<std::decay_t<It>>);
+
+  if (std::distance(it, end) >= 7)
+    IGUANA_LIKELY {
+      const auto end_m7 = end - 7;
+      for (; it < end_m7; it += 8) {
+        const auto chunk = *reinterpret_cast<const uint64_t *>(&*it);
+        uint64_t test = has_greater(chunk) | has_space(chunk);
+        if (test != 0) {
+          it += (countr_zero(test) >> 3);
+          return;
+        }
       }
     }
-  }
 
   // Tail end of buffer. Should be rare we even get here
   while (it < end) {
@@ -344,8 +186,8 @@ IGUANA_INLINE void skip_till_greater_or_space(auto &&it, auto &&end) {
   throw std::runtime_error("Expected > or space");
 }
 
-template <char c>
-IGUANA_INLINE auto skip_pass(auto &&it, auto &&end) {
+template <char c, typename It>
+IGUANA_INLINE auto skip_pass(It &&it, It &&end) {
   skip_till<c>(it, end);
   auto res = it++ - 1;
   while (*res == ' ') {
diff --git a/include/ylt/thirdparty/iguana/xml_writer.hpp b/include/ylt/thirdparty/iguana/xml_writer.hpp
index e5bb10c67..800ea6077 100644
--- a/include/ylt/thirdparty/iguana/xml_writer.hpp
+++ b/include/ylt/thirdparty/iguana/xml_writer.hpp
@@ -6,7 +6,13 @@
 
 namespace iguana {
 
-template <bool pretty, size_t spaces, typename Stream, refletable T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<sequence_container_v<T>, int> = 0>
+IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
+                                    std::string_view name);
+
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name);
 
 template <bool pretty, size_t spaces, typename Stream>
@@ -24,7 +30,7 @@ IGUANA_INLINE void render_tail(Stream &ss, std::string_view str) {
 }
 
 template <bool pretty, size_t spaces, typename Stream>
-inline void render_head(Stream &ss, std::string_view str) {
+IGUANA_INLINE void render_head(Stream &ss, std::string_view str) {
   if constexpr (pretty) {
     ss.append(spaces, '\t');
   }
@@ -33,31 +39,48 @@ inline void render_head(Stream &ss, std::string_view str) {
   ss.push_back('>');
 }
 
-template <typename Stream, plain_t T>
+template <typename Stream, typename T, std::enable_if_t<plain_v<T>, int> = 0>
 IGUANA_INLINE void render_value(Stream &ss, const T &value) {
-  if constexpr (string_t<T>) {
+  if constexpr (string_container_v<T>) {
     ss.append(value.data(), value.size());
   }
-  else if constexpr (num_t<T>) {
+  else if constexpr (num_v<T>) {
     char temp[65];
     auto p = detail::to_chars(temp, value);
     ss.append(temp, p - temp);
   }
-  else if constexpr (char_t<T>) {
+  else if constexpr (char_v<T>) {
     ss.push_back(value);
   }
-  else if constexpr (bool_t<T>) {
+  else if constexpr (bool_v<T>) {
     ss.append(value ? "true" : "false");
   }
-  else if constexpr (enum_t<T>) {
-    render_value(ss, static_cast<std::underlying_type_t<T>>(value));
+  else if constexpr (enum_v<T>) {
+    static constexpr auto enum_to_str = get_enum_map<false, std::decay_t<T>>();
+    if constexpr (bool_v<decltype(enum_to_str)>) {
+      render_value(ss, static_cast<std::underlying_type_t<T>>(value));
+    }
+    else {
+      auto it = enum_to_str.find(value);
+      if (it != enum_to_str.end())
+        IGUANA_LIKELY {
+          auto str = it->second;
+          render_value(ss, std::string_view(str.data(), str.size()));
+        }
+      else {
+        throw std::runtime_error(
+            std::to_string(static_cast<std::underlying_type_t<T>>(value)) +
+            " is a missing value in enum_value");
+      }
+    }
   }
   else {
     static_assert(!sizeof(T), "type is not supported");
   }
 }
 
-template <bool pretty, size_t spaces, typename Stream, map_container T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<map_container_v<T>, int> = 0>
 inline void render_xml_attr(Stream &ss, const T &value, std::string_view name) {
   if constexpr (pretty) {
     ss.append(spaces, '\t');
@@ -75,14 +98,16 @@ inline void render_xml_attr(Stream &ss, const T &value, std::string_view name) {
   ss.push_back('>');
 }
 
-template <bool pretty, size_t spaces, typename Stream, plain_t T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<plain_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name) {
   render_value(ss, value);
   render_tail<pretty, 0>(ss, name);
 }
 
-template <bool pretty, size_t spaces, typename Stream, optional_t T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<optional_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name) {
   if (value) {
@@ -93,7 +118,8 @@ IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
   }
 }
 
-template <bool pretty, size_t spaces, typename Stream, unique_ptr_t T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<unique_ptr_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name) {
   if (value) {
@@ -104,19 +130,21 @@ IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
   }
 }
 
-template <bool pretty, size_t spaces, typename Stream, attr_t T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<attr_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name) {
   render_xml_attr<pretty, spaces>(ss, value.attr(), name);
   render_xml_value<pretty, spaces>(ss, value.value(), name);
 }
 
-template <bool pretty, size_t spaces, typename Stream, sequence_container_t T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<sequence_container_v<T>, int>>
 IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name) {
   using value_type = typename std::remove_cvref_t<T>::value_type;
   for (const auto &v : value) {
-    if constexpr (attr_t<value_type>) {
+    if constexpr (attr_v<value_type>) {
       render_xml_value<pretty, spaces>(ss, v, name);
     }
     else {
@@ -126,7 +154,8 @@ IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
   }
 }
 
-template <bool pretty, size_t spaces, typename Stream, refletable T>
+template <bool pretty, size_t spaces, typename Stream, typename T,
+          std::enable_if_t<refletable_v<T>, int>>
 IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name) {
   if constexpr (pretty) {
     ss.push_back('\n');
@@ -141,13 +170,13 @@ IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name) {
                  std::string_view(get_name<std::decay_t<T>, Idx>().data(),
                                   get_name<std::decay_t<T>, Idx>().size());
              static_assert(Idx < Count);
-             if constexpr (sequence_container_t<value_type>) {
+             if constexpr (sequence_container_v<value_type>) {
                render_xml_value<pretty, spaces + 1>(ss, t.*v, tag_name);
              }
-             else if constexpr (attr_t<value_type>) {
+             else if constexpr (attr_v<value_type>) {
                render_xml_value<pretty, spaces + 1>(ss, t.*v, tag_name);
              }
-             else if constexpr (cdata_t<value_type>) {
+             else if constexpr (cdata_v<value_type>) {
                if constexpr (pretty) {
                  ss.append(spaces + 1, '\t');
                  ss.append("<![CDATA[").append((t.*v).value()).append("]]>\n");
@@ -164,16 +193,18 @@ IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name) {
   render_tail<pretty, spaces>(ss, name);
 }
 
-template <bool pretty = false, typename Stream, attr_t T>
+template <bool pretty = false, typename Stream, typename T,
+          std::enable_if_t<attr_v<T>, int> = 0>
 IGUANA_INLINE void to_xml(T &&t, Stream &s) {
   using value_type = typename std::decay_t<T>::value_type;
-  static_assert(refletable<value_type>, "value_type must be refletable");
+  static_assert(refletable_v<value_type>, "value_type must be refletable");
   constexpr std::string_view root_name = std::string_view(
       get_name<value_type>().data(), get_name<value_type>().size());
   render_xml_value<pretty, 0>(s, std::forward<T>(t), root_name);
 }
 
-template <bool pretty = false, typename Stream, refletable T>
+template <bool pretty = false, typename Stream, typename T,
+          std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_xml(T &&t, Stream &s) {
   constexpr std::string_view root_name = std::string_view(
       get_name<std::decay_t<T>>().data(), get_name<std::decay_t<T>>().size());
diff --git a/include/ylt/thirdparty/iguana/yaml_reader.hpp b/include/ylt/thirdparty/iguana/yaml_reader.hpp
index 1704b09a8..ea0f31213 100644
--- a/include/ylt/thirdparty/iguana/yaml_reader.hpp
+++ b/include/ylt/thirdparty/iguana/yaml_reader.hpp
@@ -8,87 +8,92 @@
 
 namespace iguana {
 
-template <refletable T, typename It>
+template <typename T, typename It, std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end,
                              size_t min_spaces = 0);
 
 namespace detail {
 
-template <str_t U, class It>
+template <typename U, typename It, std::enable_if_t<string_v<U>, int> = 0>
 IGUANA_INLINE void parse_escape_str(U &value, It &&it, It &&end) {
   auto start = it;
   while (it != end) {
-    if (*(it++) == '\\') [[unlikely]] {
-      if (*it == 'u') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        ++it;
-        if (std::distance(it, end) < 4) [[unlikely]]
+    if (*(it++) == '\\')
+      IGUANA_UNLIKELY {
+        if (*it == 'u') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          ++it;
+          if (std::distance(it, end) < 4)
+            IGUANA_UNLIKELY
           throw std::runtime_error(R"(Expected 4 hexadecimal digits)");
-        auto code_point = parse_unicode_hex4(it);
-        encode_utf8(value, code_point);
-        start = it;
-      }
-      else if (*it == 'n') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        start = ++it;
-        value.push_back('\n');
-      }
-      else if (*it == 't') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        start = ++it;
-        value.push_back('\t');
-      }
-      else if (*it == 'r') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        start = ++it;
-        value.push_back('\r');
-      }
-      else if (*it == 'b') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        start = ++it;
-        value.push_back('\b');
-      }
-      else if (*it == 'f') {
-        value.append(&*start,
-                     static_cast<size_t>(std::distance(start, it) - 1));
-        start = ++it;
-        value.push_back('\f');
+          auto code_point = parse_unicode_hex4(it);
+          encode_utf8(value, code_point);
+          start = it;
+        }
+        else if (*it == 'n') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          start = ++it;
+          value.push_back('\n');
+        }
+        else if (*it == 't') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          start = ++it;
+          value.push_back('\t');
+        }
+        else if (*it == 'r') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          start = ++it;
+          value.push_back('\r');
+        }
+        else if (*it == 'b') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          start = ++it;
+          value.push_back('\b');
+        }
+        else if (*it == 'f') {
+          value.append(&*start,
+                       static_cast<size_t>(std::distance(start, it) - 1));
+          start = ++it;
+          value.push_back('\f');
+        }
       }
-    }
   }
   value.append(&*start, static_cast<size_t>(std::distance(start, end)));
 }
 
 // use '-' here to simply represent '>-'
-template <char block_type, str_t U, class It>
+template <char block_type, typename U, typename It,
+          std::enable_if_t<string_v<U>, int> = 0>
 IGUANA_INLINE void parse_block_str(U &value, It &&it, It &&end,
                                    size_t min_spaces) {
   auto spaces = skip_space_and_lines<false>(it, end, min_spaces);
-  if (spaces < min_spaces) [[unlikely]] {
-    // back to the end of the previous line
-    if constexpr (block_type == '|' || block_type == '>') {
-      value.push_back('\n');
+  if (spaces < min_spaces)
+    IGUANA_UNLIKELY {
+      // back to the end of the previous line
+      if constexpr (block_type == '|' || block_type == '>') {
+        value.push_back('\n');
+      }
+      it -= spaces + 1;
+      return;
     }
-    it -= spaces + 1;
-    return;
-  }
   while (it != end) {
     auto start = it;
     auto value_end = skip_till_newline(it, end);
     value.append(&*start, static_cast<size_t>(std::distance(start, value_end)));
     spaces = skip_space_and_lines<false>(it, end, min_spaces);
-    if ((spaces < min_spaces) || (it == end)) [[unlikely]] {
-      if constexpr (block_type == '|' || block_type == '>') {
-        value.push_back('\n');
+    if ((spaces < min_spaces) || (it == end))
+      IGUANA_UNLIKELY {
+        if constexpr (block_type == '|' || block_type == '>') {
+          value.push_back('\n');
+        }
+        it -= spaces + 1;
+        return;
       }
-      it -= spaces + 1;
-      return;
-    }
     if constexpr (block_type == '|') {
       value.push_back('\n');
     }
@@ -98,23 +103,25 @@ IGUANA_INLINE void parse_block_str(U &value, It &&it, It &&end,
   }
 }
 
-template <map_container U, class It>
+template <typename U, typename It,
+          std::enable_if_t<map_container_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces);
 
-template <num_t U, class It>
+template <typename U, class It, std::enable_if_t<num_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
-  if (value_begin == value_end) [[unlikely]] {
-    return;
-  }
+  if (value_begin == value_end)
+    IGUANA_UNLIKELY { return; }
   auto size = std::distance(value_begin, value_end);
   const auto start = &*value_begin;
   auto [p, ec] = detail::from_chars(start, start + size, value);
-  if (ec != std::errc{}) [[unlikely]]
-    throw std::runtime_error("Failed to parse number");
+  if (ec != std::errc{})
+    IGUANA_UNLIKELY
+  throw std::runtime_error("Failed to parse number");
 }
 
 // string_view should be used  for string with ' " ?
-template <string_t U, class It>
+template <typename U, typename It,
+          std::enable_if_t<string_container_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
   using T = std::decay_t<U>;
   auto start = value_begin;
@@ -122,10 +129,18 @@ IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
   if (*value_begin == '"') {
     ++start;
     --end;
-    if (*end != '"') [[unlikely]] {
-      throw std::runtime_error(R"(Expected ")");
-    }
-    if constexpr (str_t<T>) {
+    if (*end != '"')
+      IGUANA_UNLIKELY {
+        // TODO: improve
+        auto it = start;
+        while (*it != '"' && it != end) {
+          ++it;
+        }
+        if (it == end || (*(it + 1) != '#'))
+          IGUANA_UNLIKELY { throw std::runtime_error(R"(Expected ")"); }
+        end = it;
+      }
+    if constexpr (string_v<T>) {
       parse_escape_str(value, start, end);
       return;
     }
@@ -133,29 +148,42 @@ IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
   else if (*value_begin == '\'') {
     ++start;
     --end;
-    if (*end != '\'') [[unlikely]] {
-      throw std::runtime_error(R"(Expected ')");
-    }
+    if (*end != '\'')
+      IGUANA_UNLIKELY { throw std::runtime_error(R"(Expected ')"); }
   }
   value = T(&*start, static_cast<size_t>(std::distance(start, end)));
 }
 
-template <char_t U, class It>
+template <typename U, typename It, std::enable_if_t<char_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
   if (static_cast<size_t>(std::distance(value_begin, value_end)) != 1)
-      [[unlikely]] {
-    throw std::runtime_error("Expected one character");
-  }
+    IGUANA_UNLIKELY { throw std::runtime_error("Expected one character"); }
   value = *value_begin;
 }
 
-template <enum_t U, class It>
+template <typename U, typename It, std::enable_if_t<enum_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &value, It &&value_begin, It &&value_end) {
-  using T = std::underlying_type_t<std::decay_t<U>>;
-  parse_value(reinterpret_cast<T &>(value), value_begin, value_end);
+  static constexpr auto str_to_enum = get_enum_map<true, std::decay_t<U>>();
+  if constexpr (bool_v<decltype(str_to_enum)>) {
+    // not defined a specialization template
+    using T = std::underlying_type_t<std::decay_t<U>>;
+    parse_value(reinterpret_cast<T &>(value), value_begin, value_end);
+  }
+  else {
+    auto enum_names = std::string_view(
+        &*value_begin,
+        static_cast<size_t>(std::distance(value_begin, value_end)));
+    auto it = str_to_enum.find(enum_names);
+    if (it != str_to_enum.end())
+      IGUANA_LIKELY { value = it->second; }
+    else {
+      throw std::runtime_error(std::string(enum_names) +
+                               " missing corresponding value in enum_value");
+    }
+  }
 }
 
-template <bool_t U, class It>
+template <typename U, typename It, std::enable_if_t<bool_v<U>, int> = 0>
 IGUANA_INLINE void parse_value(U &&value, It &&value_begin, It &&value_end) {
   auto bool_v = std::string_view(
       &*value_begin,
@@ -166,23 +194,21 @@ IGUANA_INLINE void parse_value(U &&value, It &&value_begin, It &&value_end) {
   else if (bool_v == "false") {
     value = false;
   }
-  else [[unlikely]] {
-    throw std::runtime_error("Expected true or false");
-  }
+  else
+    IGUANA_UNLIKELY { throw std::runtime_error("Expected true or false"); }
 }
 
-template <refletable U, class It>
+template <typename U, typename It, std::enable_if_t<refletable_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   from_yaml(value, it, end, min_spaces);
 }
 
-template <plain_t U, class It>
+template <typename U, typename It, std::enable_if_t<plain_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   using T = std::decay_t<U>;
-  if constexpr (str_t<T>) {
-    if (skip_space_till_end(it, end)) [[unlikely]] {
-      return;
-    }
+  if constexpr (string_v<T>) {
+    if (skip_space_till_end(it, end))
+      IGUANA_UNLIKELY { return; }
     if (*it == '|') {
       ++it;
       parse_block_str<'|'>(value, it, end, min_spaces);
@@ -212,14 +238,15 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   }
 }
 
-template <optional_t U, class It>
+template <typename U, typename It, std::enable_if_t<optional_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces);
 
-template <unique_ptr_t U, class It>
+template <typename U, typename It, std::enable_if_t<unique_ptr_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces);
 
 // minspaces : The minimum indentation
-template <sequence_container_t U, class It>
+template <typename U, typename It,
+          std::enable_if_t<sequence_container_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   value.clear();
   auto spaces = skip_space_and_lines(it, end, min_spaces);
@@ -228,24 +255,23 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
     ++it;
     skip_space_and_lines(it, end, min_spaces);
     while (it != end) {
-      if (*it == ']') [[unlikely]] {
-        ++it;
-        return;
-      }
-      if constexpr (plain_t<value_type>) {
+      if (*it == ']')
+        IGUANA_UNLIKELY {
+          ++it;
+          return;
+        }
+      if constexpr (plain_v<value_type>) {
         auto start = it;
         auto value_end = skip_till<',', ']'>(it, end);
         parse_value(value.emplace_back(), start, value_end);
-        if (*(it - 1) == ']') [[unlikely]] {
-          return;
-        }
+        if (*(it - 1) == ']')
+          IGUANA_UNLIKELY { return; }
       }
       else {
         parse_item(value.emplace_back(), it, end, spaces + 1);
         skip_space_and_lines(it, end, min_spaces);
-        if (*it == ',') [[likely]] {
-          ++it;
-        }
+        if (*it == ',')
+          IGUANA_LIKELY { ++it; }
       }
       skip_space_and_lines(it, end, min_spaces);
     }
@@ -253,20 +279,22 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   else if (*it == '-') {
     while (it != end) {
       auto subspaces = skip_space_and_lines<false>(it, end, spaces);
-      if (subspaces < spaces) [[unlikely]] {
-        it -= subspaces + 1;
-        return;
-      }
-      if (it == end) [[unlikely]]
-        return;
+      if (subspaces < spaces)
+        IGUANA_UNLIKELY {
+          it -= subspaces + 1;
+          return;
+        }
+      if (it == end)
+        IGUANA_UNLIKELY
+      return;
       match<'-'>(it, end);
       // space + 1 because of the skipped '-'
       subspaces = skip_space_and_lines(it, end, spaces + 1);
-      if constexpr (str_t<value_type>) {
-        // except str_t because of scalar blocks
+      if constexpr (string_v<value_type>) {
+        // except string_v because of scalar blocks
         parse_item(value.emplace_back(), it, end, spaces + 1);
       }
-      else if constexpr (plain_t<value_type>) {
+      else if constexpr (plain_v<value_type>) {
         auto start = it;
         auto value_end = skip_till_newline(it, end);
         parse_value(value.emplace_back(), start, value_end);
@@ -276,12 +304,11 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
       }
     }
   }
-  else [[unlikely]] {
-    throw std::runtime_error("Expected ']' or '-'");
-  }
+  else
+    IGUANA_UNLIKELY { throw std::runtime_error("Expected ']' or '-'"); }
 }
 
-template <tuple_t U, class It>
+template <typename U, typename It, std::enable_if_t<tuple_v<U>, int> = 0>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   auto spaces = skip_space_and_lines(it, end, min_spaces);
   if (*it == '[') {
@@ -290,7 +317,7 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
     for_each(value, [&](auto &v, auto i) IGUANA__INLINE_LAMBDA {
       using value_type = std::decay_t<decltype(v)>;
       skip_space_and_lines(it, end, min_spaces);
-      if constexpr (plain_t<value_type>) {
+      if constexpr (plain_v<value_type>) {
         auto start = it;
         auto value_end = skip_till<',', ']'>(it, end);
         parse_value(v, start, value_end);
@@ -311,10 +338,10 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
       skip_space_and_lines(it, end, spaces);
       match<'-'>(it, end);
       auto subspaces = skip_space_and_lines(it, end, spaces + 1);
-      if constexpr (str_t<value_type>) {
+      if constexpr (string_v<value_type>) {
         parse_item(v, it, end, spaces + 1);
       }
-      else if constexpr (plain_t<value_type>) {
+      else if constexpr (plain_v<value_type>) {
         auto start = it;
         auto value_end = skip_till_newline(it, end);
         parse_value(v, start, value_end);
@@ -329,7 +356,7 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   }
 }
 
-template <map_container U, class It>
+template <typename U, typename It, std::enable_if_t<map_container_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   using T = std::remove_reference_t<U>;
   using key_type = typename T::key_type;
@@ -339,29 +366,28 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
     ++it;
     auto subspaces = skip_space_and_lines(it, end, min_spaces);
     while (it != end) {
-      if (*it == '}') [[unlikely]] {
-        ++it;
-        return;
-      }
+      if (*it == '}')
+        IGUANA_UNLIKELY {
+          ++it;
+          return;
+        }
       auto start = it;
       auto value_end = skip_till<':'>(it, end);
       key_type key;
       parse_value(key, start, value_end);
       subspaces = skip_space_and_lines(it, end, min_spaces);
-      if constexpr (plain_t<value_type>) {
+      if constexpr (plain_v<value_type>) {
         start = it;
         value_end = skip_till<',', '}'>(it, end);
         parse_value(value[key], start, value_end);
-        if (*(it - 1) == '}') [[unlikely]] {
-          return;
-        }
+        if (*(it - 1) == '}')
+          IGUANA_UNLIKELY { return; }
       }
       else {
         parse_item(value[key], it, end, min_spaces);
         subspaces = skip_space_and_lines(it, end, min_spaces);
-        if (*it == ',') [[likely]] {
-          ++it;
-        }
+        if (*it == ',')
+          IGUANA_LIKELY { ++it; }
       }
       subspaces = skip_space_and_lines(it, end, min_spaces);
     }
@@ -369,16 +395,17 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   else {
     auto subspaces = skip_space_and_lines<false>(it, end, min_spaces);
     while (it != end) {
-      if (subspaces < min_spaces) [[unlikely]] {
-        it -= subspaces + 1;
-        return;
-      }
+      if (subspaces < min_spaces)
+        IGUANA_UNLIKELY {
+          it -= subspaces + 1;
+          return;
+        }
       auto start = it;
       auto value_end = skip_till<':'>(it, end);
       key_type key;
       parse_value(key, start, value_end);
       subspaces = skip_space_and_lines(it, end, min_spaces);
-      if constexpr (plain_t<value_type> && !str_t<value_type>) {
+      if constexpr (plain_v<value_type> && !string_v<value_type>) {
         start = it;
         value_end = skip_till_newline(it, end);
         parse_value(value[key], start, value_end);
@@ -391,27 +418,27 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   }
 }
 
-template <unique_ptr_t U, class It>
+template <typename U, typename It, std::enable_if_t<unique_ptr_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   using T = std::remove_reference_t<U>;
   value = std::make_unique<typename T::element_type>();
-  static_assert(!str_t<typename T::element_type>,
+  static_assert(!string_v<typename T::element_type>,
                 "unique_ptr<string> is not allowed");
   parse_item(*value, it, end, min_spaces);
 }
 
-template <optional_t U, class It>
+template <typename U, typename It, std::enable_if_t<optional_v<U>, int>>
 IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
   using T = std::remove_reference_t<U>;
   using value_type = typename T::value_type;
   auto spaces = skip_space_and_lines<false>(it, end, min_spaces);
-  if (it == end) [[unlikely]] {
-    return;
-  }
-  if (spaces < min_spaces) [[unlikely]] {
-    it -= spaces + 1;
-    return;
-  }
+  if (it == end)
+    IGUANA_UNLIKELY { return; }
+  if (spaces < min_spaces)
+    IGUANA_UNLIKELY {
+      it -= spaces + 1;
+      return;
+    }
   auto start = it;
   std::decay_t<It> value_end = end;
   if (*it == 'n') {
@@ -422,20 +449,22 @@ IGUANA_INLINE void parse_item(U &value, It &&it, It &&end, size_t min_spaces) {
       return;
     }
   }
-  if constexpr (str_t<value_type> || !plain_t<value_type>) {
+  if constexpr (string_v<value_type> || !plain_v<value_type>) {
     it = start;
     parse_item(value.emplace(), it, end, min_spaces);
   }
   else {
-    if (value_end == end) [[likely]] {
-      // if value_end isn't touched
-      value_end = skip_till_newline(it, end);
-    }
+    if (value_end == end)
+      IGUANA_LIKELY {
+        // if value_end isn't touched
+        value_end = skip_till_newline(it, end);
+      }
     parse_value(value.emplace(), start, value_end);
   }
 }
 
-IGUANA_INLINE void skip_object_value(auto &&it, auto &&end, size_t min_spaces) {
+template <typename It>
+IGUANA_INLINE void skip_object_value(It &&it, It &&end, size_t min_spaces) {
   int subspace = min_spaces;
   while (it != end) {
     while (it != end && *it != '\n') {
@@ -443,9 +472,8 @@ IGUANA_INLINE void skip_object_value(auto &&it, auto &&end, size_t min_spaces) {
     }
     // here : it == '\n'
     subspace = 0;
-    if (it != end) [[likely]] {
-      ++it;
-    }
+    if (it != end)
+      IGUANA_LIKELY { ++it; }
     while (it != end && *(it++) == ' ') {
       ++subspace;
     }
@@ -458,7 +486,7 @@ IGUANA_INLINE void skip_object_value(auto &&it, auto &&end, size_t min_spaces) {
 
 }  // namespace detail
 
-template <refletable T, typename It>
+template <typename T, typename It, std::enable_if_t<refletable_v<T>, int>>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end, size_t min_spaces) {
   auto spaces = skip_space_and_lines(it, end, min_spaces);
   while (it != end) {
@@ -469,36 +497,40 @@ IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end, size_t min_spaces) {
     static constexpr auto frozen_map = get_iguana_struct_map<T>();
     if constexpr (frozen_map.size() > 0) {
       const auto &member_it = frozen_map.find(key);
-      if (member_it != frozen_map.end()) [[likely]] {
-        std::visit(
-            [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
-              using V = std::decay_t<decltype(member_ptr)>;
-              if constexpr (std::is_member_pointer_v<V>) {
-                detail::parse_item(value.*member_ptr, it, end, spaces + 1);
-              }
-              else {
-                static_assert(!sizeof(V), "type not supported");
-              }
-            },
-            member_it->second);
-      }
-      else [[unlikely]] {
+      if (member_it != frozen_map.end())
+        IGUANA_LIKELY {
+          std::visit(
+              [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
+                using V = std::decay_t<decltype(member_ptr)>;
+                if constexpr (std::is_member_pointer_v<V>) {
+                  detail::parse_item(value.*member_ptr, it, end, spaces + 1);
+                }
+                else {
+                  static_assert(!sizeof(V), "type not supported");
+                }
+              },
+              member_it->second);
+        }
+      else
+        IGUANA_UNLIKELY {
 #ifdef THROW_UNKNOWN_KEY
-        throw std::runtime_error("Unknown key: " + std::string(key));
+          throw std::runtime_error("Unknown key: " + std::string(key));
 #else
-        detail::skip_object_value(it, end, spaces + 1);
+          detail::skip_object_value(it, end, spaces + 1);
 #endif
-      }
+        }
     }
     auto subspaces = skip_space_and_lines<false>(it, end, min_spaces);
-    if (subspaces < min_spaces) [[unlikely]] {
-      it -= subspaces + 1;
-      return;
-    }
+    if (subspaces < min_spaces)
+      IGUANA_UNLIKELY {
+        it -= subspaces + 1;
+        return;
+      }
   }
 }
 
-template <non_refletable T, typename It>
+template <typename T, typename It,
+          std::enable_if_t<non_refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end) {
   detail::parse_item(value, it, end, 0);
 }
@@ -514,12 +546,14 @@ IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end,
   }
 }
 
-template <typename T, string_t View>
+template <typename T, typename View,
+          std::enable_if_t<string_container_v<View>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, const View &view) {
   from_yaml(value, std::begin(view), std::end(view));
 }
 
-template <typename T, string_t View>
+template <typename T, typename View,
+          std::enable_if_t<string_container_v<View>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, const View &view,
                              std::error_code &ec) noexcept {
   try {
diff --git a/include/ylt/thirdparty/iguana/yaml_util.hpp b/include/ylt/thirdparty/iguana/yaml_util.hpp
index 5c43f47fa..00e444614 100644
--- a/include/ylt/thirdparty/iguana/yaml_util.hpp
+++ b/include/ylt/thirdparty/iguana/yaml_util.hpp
@@ -1,209 +1,80 @@
 #pragma once
 
-#include <math.h>
-
-#include <bit>
-#include <filesystem>
-#include <forward_list>
-#include <fstream>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string_view>
-#include <type_traits>
-
-#include "define.h"
-#include "reflection.hpp"
-#include "value.hpp"
+#include "util.hpp"
 
 namespace iguana {
-
-template <class T>
-concept char_t = std::same_as < std::decay_t<T>,
-char > || std::same_as<std::decay_t<T>, char16_t> ||
-    std::same_as<std::decay_t<T>, char32_t> ||
-    std::same_as<std::decay_t<T>, wchar_t>;
-
-template <class T>
-concept bool_t = std::same_as < std::decay_t<T>,
-bool > || std::same_as<std::decay_t<T>, std::vector<bool>::reference>;
-
-template <class T>
-concept int_t =
-    std::integral<std::decay_t<T>> && !char_t<std::decay_t<T>> && !bool_t<T>;
-
-template <class T>
-concept float_t = std::floating_point<std::decay_t<T>>;
-
-template <class T>
-concept num_t = std::floating_point<std::decay_t<T>> || int_t<T>;
-
-template <class T>
-concept enum_t = std::is_enum_v<std::decay_t<T>>;
-
-template <typename T>
-constexpr inline bool is_basic_string_view = false;
-
-template <typename T>
-constexpr inline bool is_basic_string_view<std::basic_string_view<T>> = true;
-
-template <typename T>
-concept str_view_t = is_basic_string_view<std::remove_reference_t<T>>;
-
-template <class T>
-concept str_t =
-    std::convertible_to<std::decay_t<T>, std::string_view> && !str_view_t<T>;
-
-template <class T>
-concept string_t = std::convertible_to<std::decay_t<T>, std::string_view>;
-
-template <class T>
-concept tuple_t = is_tuple<std::remove_cvref_t<T>>::value;
-
-template <class T>
-concept sequence_container_t =
-    is_sequence_container<std::remove_cvref_t<T>>::value;
-
-template <typename Type>
-concept unique_ptr_t = requires(Type ptr) {
-  ptr.operator*();
-  typename std::remove_cvref_t<Type>::element_type;
-}
-&&!requires(Type ptr, Type ptr2) { ptr = ptr2; };
-
-template <typename Type>
-concept optional_t = requires(Type optional) {
-  optional.value();
-  optional.has_value();
-  optional.operator*();
-  typename std::remove_cvref_t<Type>::value_type;
-};
-
-template <typename Type>
-concept container = requires(Type container) {
-  typename std::remove_cvref_t<Type>::value_type;
-  container.size();
-  container.begin();
-  container.end();
-};
-template <typename Type>
-concept map_container = container<Type> && requires(Type container) {
-  typename std::remove_cvref_t<Type>::mapped_type;
-};
-
-template <class T>
-concept plain_t =
-    string_t<T> || num_t<T> || char_t<T> || bool_t<T> || enum_t<T>;
-
-template <class T>
-concept c_array = std::is_array_v<std::remove_cvref_t<T>> &&
-                  std::extent_v<std::remove_cvref_t<T>> >
-0;
-
-template <typename Type>
-concept array = requires(Type arr) {
-  arr.size();
-  std::tuple_size<std::remove_cvref_t<Type>>{};
-};
-
-template <typename Type>
-concept tuple = !array<Type> && requires(Type tuple) {
-  std::get<0>(tuple);
-  sizeof(std::tuple_size<std::remove_cvref_t<Type>>);
-};
-
-template <typename T>
-concept refletable = is_reflection_v<std::remove_cvref_t<T>>;
-
-// TODO: support c_array
-template <class T>
-concept non_refletable = container<T> || c_array<T> || tuple<T> ||
-    optional_t<T> || unique_ptr_t<T> || std::is_fundamental_v<T>;
-
-IGUANA_INLINE void skip_yaml_comment(auto &&it, auto &&end) {
-  while (++it != end && *it != '\n')
-    ;
-}
-
-// match c and skip
-template <char c>
-IGUANA_INLINE void match(auto &&it, auto &&end) {
-  if (it == end || *it != c) [[unlikely]] {
-    static constexpr char b[] = {c, '\0'};
-    std::string error = std::string("Expected:").append(b);
-    throw std::runtime_error(error);
-  }
-  else [[likely]] {
-    ++it;
-  }
-}
-
 // return true when it==end
-IGUANA_INLINE bool skip_space_till_end(auto &&it, auto &&end) {
-  while (it != end && *it == ' ') ++it;
+template <typename It>
+IGUANA_INLINE bool skip_space_till_end(It &&it, It &&end) {
+  while (it != end && *it < 33) ++it;
   return it == end;
 }
 
 // will not skip  '\n'
-IGUANA_INLINE auto skip_till_newline(auto &&it, auto &&end) {
-  if (it == end) [[unlikely]] {
-    return it;
-  }
+template <typename It>
+IGUANA_INLINE auto skip_till_newline(It &&it, It &&end) {
+  if (it == end)
+    IGUANA_UNLIKELY { return it; }
   std::decay_t<decltype(it)> res = it;
   while ((it != end) && (*it != '\n')) {
-    if (*it == ' ') [[unlikely]] {
-      res = it;
-      while (it != end && *it == ' ') ++it;
-    }
-    else if (*it == '#') [[unlikely]] {
-      if (*(it - 1) == ' ') [[unlikely]] {
-        // it - 1 should be legal because this func is for parse value
-        while ((it != end) && *it != '\n') {
+    if (*it == ' ')
+      IGUANA_UNLIKELY {
+        res = it;
+        while (it != end && *it == ' ') ++it;
+      }
+    else if (*it == '#')
+      IGUANA_UNLIKELY {
+        if (*(it - 1) == ' ') {
+          // it - 1 should be legal because this func is for parse value
+          while ((it != end) && *it != '\n') {
+            ++it;
+          }
+          return res;
+        }
+        else {
           ++it;
         }
-        return res;
       }
-    }
-    else [[likely]] {
-      ++it;
-    }
+    else
+      IGUANA_LIKELY { ++it; }
   }
   return (*(it - 1) == ' ') ? res : it;
 }
 
-template <char... C>
-IGUANA_INLINE auto skip_till(auto &&it, auto &&end) {
-  if (it == end) [[unlikely]] {
-    return it;
-  }
+template <char... C, typename It>
+IGUANA_INLINE auto skip_till(It &&it, It &&end) {
+  if (it == end)
+    IGUANA_UNLIKELY { return it; }
   std::decay_t<decltype(it)> res = it;
   while ((it != end) && (!((... || (*it == C))))) {
-    if (*it == '\n') [[unlikely]] {
-      throw std::runtime_error("\\n is not expected");
-    }
-    else if (*it == ' ') [[unlikely]] {
-      res = it;
-      while (it != end && *it == ' ') ++it;
-    }
-    else if (*it == '#') [[unlikely]] {
-      if (*(it - 1) == ' ') [[unlikely]] {
-        // it - 1 may be illegal
-        while ((it != end) && *it != '\n') {
-          ++it;
-        }
-        return res;
+    if (*it == '\n')
+      IGUANA_UNLIKELY { throw std::runtime_error("\\n is not expected"); }
+    else if (*it == ' ')
+      IGUANA_UNLIKELY {
+        res = it;
+        while (it != end && *it == ' ') ++it;
       }
-    }
-    else [[likely]] {
-      ++it;
-    }
+    else if (*it == '#')
+      IGUANA_UNLIKELY {
+        if (*(it - 1) == ' ')
+          IGUANA_UNLIKELY {
+            // it - 1 may be illegal
+            while ((it != end) && *it != '\n') {
+              ++it;
+            }
+            return res;
+          }
+      }
+    else
+      IGUANA_LIKELY { ++it; }
   }
 
-  if (it == end) [[unlikely]] {
-    static constexpr char b[] = {C..., '\0'};
-    std::string error = std::string("Expected one of these: ").append(b);
-    throw std::runtime_error(error);
-  }
+  if (it == end)
+    IGUANA_UNLIKELY {
+      static constexpr char b[] = {C..., '\0'};
+      std::string error = std::string("Expected one of these: ").append(b);
+      throw std::runtime_error(error);
+    }
   ++it;  // skip
   return (*(it - 2) == ' ') ? res : it - 1;
 }
@@ -211,9 +82,8 @@ IGUANA_INLINE auto skip_till(auto &&it, auto &&end) {
 // If there are '\n' , return indentation
 // If not, return minspaces + space
 // If Throw == true, check  res < minspaces
-template <bool Throw = true>
-IGUANA_INLINE size_t skip_space_and_lines(auto &&it, auto &&end,
-                                          size_t minspaces) {
+template <bool Throw = true, typename It>
+IGUANA_INLINE size_t skip_space_and_lines(It &&it, It &&end, size_t minspaces) {
   size_t res = minspaces;
   while (it != end) {
     if (*it == '\n') {
@@ -221,16 +91,17 @@ IGUANA_INLINE size_t skip_space_and_lines(auto &&it, auto &&end,
       res = 0;
       auto start = it;
       // skip the --- line
-      if ((it != end) && (*it == '-')) [[unlikely]] {
-        auto line_end = skip_till<false, '\n'>(it, end);
-        auto line = std::string_view(
-            &*start, static_cast<size_t>(std::distance(start, line_end)));
-        if (line != "---") {
-          it = start;
+      if ((it != end) && (*it == '-'))
+        IGUANA_UNLIKELY {
+          auto line_end = skip_till<false, '\n'>(it, end);
+          auto line = std::string_view(
+              &*start, static_cast<size_t>(std::distance(start, line_end)));
+          if (line != "---") {
+            it = start;
+          }
         }
-      }
     }
-    else if (*it == ' ') {
+    else if (*it == ' ' || *it == '\t') {
       ++it;
       ++res;
     }
@@ -242,9 +113,8 @@ IGUANA_INLINE size_t skip_space_and_lines(auto &&it, auto &&end,
     }
     else {
       if constexpr (Throw) {
-        if (res < minspaces) [[unlikely]] {
-          throw std::runtime_error("Indentation problem");
-        }
+        if (res < minspaces)
+          IGUANA_UNLIKELY { throw std::runtime_error("Indentation problem"); }
       }
       return res;
     }
diff --git a/include/ylt/thirdparty/iguana/yaml_writer.hpp b/include/ylt/thirdparty/iguana/yaml_writer.hpp
index 1a6117205..781f25bf4 100644
--- a/include/ylt/thirdparty/iguana/yaml_writer.hpp
+++ b/include/ylt/thirdparty/iguana/yaml_writer.hpp
@@ -5,24 +5,28 @@
 
 namespace iguana {
 
-template <typename Stream, refletable T>
+template <typename Stream, typename T,
+          std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s, size_t min_spaces = 0);
 
-template <typename Stream, refletable T>
+template <typename Stream, typename T,
+          std::enable_if_t<refletable_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
   ss.push_back('\n');
   to_yaml(std::forward<T>(t), ss, min_spaces);
 }
 
 // TODO: support more string style, support escape
-template <bool appendLf = true, typename Stream, string_t T>
+template <bool appendLf = true, typename Stream, typename T,
+          std::enable_if_t<string_container_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
   ss.append(t.data(), t.size());
   if constexpr (appendLf)
     ss.push_back('\n');
 }
 
-template <bool appendLf = true, typename Stream, num_t T>
+template <bool appendLf = true, typename Stream, typename T,
+          std::enable_if_t<num_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T value, size_t min_spaces) {
   char temp[65];
   auto p = detail::to_chars(temp, value);
@@ -47,21 +51,41 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, bool value,
     ss.push_back('\n');
 }
 
-template <bool appendLf = true, typename Stream, enum_t T>
+template <bool appendLf = true, typename Stream, typename T,
+          std::enable_if_t<enum_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T value, size_t min_spaces) {
-  render_yaml_value(ss, static_cast<std::underlying_type_t<T>>(value),
-                    min_spaces);
+  static constexpr auto enum_to_str = get_enum_map<false, std::decay_t<T>>();
+  if constexpr (bool_v<decltype(enum_to_str)>) {
+    render_yaml_value(ss, static_cast<std::underlying_type_t<T>>(value),
+                      min_spaces);
+  }
+  else {
+    auto it = enum_to_str.find(value);
+    if (it != enum_to_str.end())
+      IGUANA_LIKELY {
+        auto str = it->second;
+        render_yaml_value(ss, std::string_view(str.data(), str.size()),
+                          min_spaces);
+      }
+    else {
+      throw std::runtime_error(
+          std::to_string(static_cast<std::underlying_type_t<T>>(value)) +
+          " is a missing value in enum_value");
+    }
+  }
 }
 
-template <typename Stream, optional_t T>
+template <typename Stream, typename T, std::enable_if_t<optional_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
                                      size_t min_spaces);
 
-template <typename Stream, unique_ptr_t T>
+template <typename Stream, typename T,
+          std::enable_if_t<unique_ptr_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
                                      size_t min_spaces);
 
-template <typename Stream, sequence_container_t T>
+template <typename Stream, typename T,
+          std::enable_if_t<sequence_container_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &t,
                                      size_t min_spaces) {
   ss.push_back('\n');
@@ -72,7 +96,7 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, const T &t,
   }
 }
 
-template <typename Stream, tuple_t T>
+template <typename Stream, typename T, std::enable_if_t<tuple_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
   ss.push_back('\n');
   for_each(std::forward<T>(t),
@@ -83,7 +107,8 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
            });
 }
 
-template <typename Stream, map_container T>
+template <typename Stream, typename T,
+          std::enable_if_t<map_container_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &t,
                                      size_t min_spaces) {
   ss.push_back('\n');
@@ -95,7 +120,7 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, const T &t,
   }
 }
 
-template <typename Stream, optional_t T>
+template <typename Stream, typename T, std::enable_if_t<optional_v<T>, int>>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
                                      size_t min_spaces) {
   if (!val) {
@@ -107,7 +132,7 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
   }
 }
 
-template <typename Stream, unique_ptr_t T>
+template <typename Stream, typename T, std::enable_if_t<unique_ptr_v<T>, int>>
 IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
                                      size_t min_spaces) {
   if (!val) {
@@ -124,7 +149,7 @@ constexpr auto write_yaml_key = [](auto &s, auto i,
   s.append(name.data(), name.size());
 };
 
-template <typename Stream, refletable T>
+template <typename Stream, typename T, std::enable_if_t<refletable_v<T>, int>>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s, size_t min_spaces) {
   for_each(std::forward<T>(t),
            [&t, &s, min_spaces](const auto &v, auto i) IGUANA__INLINE_LAMBDA {
@@ -145,10 +170,11 @@ IGUANA_INLINE void to_yaml(T &&t, Stream &s, size_t min_spaces) {
            });
 }
 
-template <typename Stream, non_refletable T>
+template <typename Stream, typename T,
+          std::enable_if_t<non_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s) {
-  if constexpr (tuple_t<T> || map_container<T> || sequence_container_t<T> ||
-                optional_t<T> || unique_ptr_t<T>)
+  if constexpr (tuple_v<T> || map_container_v<T> || sequence_container_v<T> ||
+                optional_v<T> || unique_ptr_v<T>)
     render_yaml_value(s, std::forward<T>(t), 0);
   else
     static_assert(!sizeof(T), "don't suppport this type");
diff --git a/src/struct_json/examples/main.cpp b/src/struct_json/examples/main.cpp
index 3943116ab..2018d3df0 100644
--- a/src/struct_json/examples/main.cpp
+++ b/src/struct_json/examples/main.cpp
@@ -16,7 +16,7 @@ bool operator==(const person& a, const person& b) {
 REFLECTION(person, name, age);
 
 int main() {
-  person p{.name = "tom", .age = 20};
+  person p{"tom", 20};
   std::string str;
 
   // struct to json