Release 2.2.0 (#2207)

2024-10-20 09:42:12 +08:00 · 2024-10-20 09:42:12 +08:00 · 7be00213a9
parent 8a9ad35d58
commit 7be00213a9
22 changed files with 3674 additions and 4002 deletions
--- a/1k/manifest.ps1
+++ b/1k/manifest.ps1
@ -11,8 +11,8 @@
 if ($Global:is_axmol_app -or $Global:is_axmol_engine) {
    $manifest['nuget'] = '5.5.1' # since 5.6.0, requires .net 4.0
    $manifest['glslcc'] = '1.9.5+'
-    $manifest['cmake'] = '3.29.3~3.30.3+'
-    $manifest['emsdk'] = '3.1.66~3.1.67+'
+    $manifest['cmake'] = '3.29.3~3.30.5+'
+    $manifest['emsdk'] = '3.1.66~3.1.69+'
    $manifest['jdk'] = '17.0.10~17.0.12+'
    $manifest['vs'] = '16.0+'
 }
--- a/3rdparty/README.md
+++ b/3rdparty/README.md
@ -67,7 +67,8 @@

 ## {fmt}
 - [![Upstream](https://img.shields.io/github/v/release/fmtlib/fmt?label=Upstream)](https://github.com/fmtlib/fmt)
- Version: 11.0.2
+- Version: 11.0.2-601be1c
+
 - License: MIT

 ## FreeType
@ -123,7 +124,7 @@

 - luajit
  - Upstream: https://github.com/LuaJIT/LuaJIT
-  - Version: 2.1-87ae18a
+  - Version: 2.1-97813fb
  - License: MIT

 - tolua
--- a/3rdparty/fmt/CMakeLists.txt
+++ b/3rdparty/fmt/CMakeLists.txt
@ -240,7 +240,13 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  endif ()
  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
-          -Wnull-dereference -Wduplicated-cond)
+          -Wduplicated-cond)
+      # Workaround for GCC regression
+      # [12/13/14/15 regression] New (since gcc 12) false positive null-dereference in vector.resize
+      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108860
+      if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+        set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wnull-dereference)
+      endif ()
  endif ()
  set(WERROR_FLAG -Werror)
 endif ()
@ -319,7 +325,7 @@ else ()
  message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
 endif ()

-target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
+target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

@ -359,8 +365,8 @@ if (NOT MSVC)
  # Unicode is always supported on compilers other than MSVC.
 elseif (FMT_UNICODE)
  # Unicode support requires compiling with /utf-8.
-  target_compile_options(fmt PUBLIC $<$<COMPILE_LANGUAGE:CXX>:/utf-8>)
-  target_compile_options(fmt-header-only INTERFACE $<$<COMPILE_LANGUAGE:CXX>:/utf-8>)
+  target_compile_options(fmt PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
+  target_compile_options(fmt-header-only INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
 else ()
  target_compile_definitions(fmt PUBLIC FMT_UNICODE=0)
 endif ()
@ -369,7 +375,7 @@ target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
 target_compile_features(fmt-header-only INTERFACE cxx_std_11)

 target_include_directories(fmt-header-only
-  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
+  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} BEFORE INTERFACE
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)

--- a/3rdparty/fmt/ChangeLog.md
+++ b/3rdparty/fmt/ChangeLog.md
@ -1,3 +1,7 @@
+# 11.1.0 - TBD
+
+- Improved debug codegen.
+
 # 11.0.2 - 2024-07-20

 - Fixed compatibility with non-POSIX systems
--- a/3rdparty/fmt/README.md
+++ b/3rdparty/fmt/README.md
@ -291,6 +291,7 @@ converts to `std::print`.)
 - [ccache](https://ccache.dev/): a compiler cache
 - [ClickHouse](https://github.com/ClickHouse/ClickHouse): an
  analytical database management system
+- [ContextVision](https://www.contextvision.com/): medical imaging software
 - [Contour](https://github.com/contour-terminal/contour/): a modern
  terminal emulator
 - [CUAUV](https://cuauv.org/): Cornell University\'s autonomous
--- a/3rdparty/fmt/include/fmt/args.h
+++ b/3rdparty/fmt/include/fmt/args.h
@ -17,7 +17,6 @@
 #include "format.h"  // std_string_view

 FMT_BEGIN_NAMESPACE
-
 namespace detail {

 template <typename T> struct is_reference_wrapper : std::false_type {};
@ -72,19 +71,13 @@ class dynamic_arg_list {
 * It can be implicitly converted into `fmt::basic_format_args` for passing
 * into type-erased formatting functions such as `fmt::vformat`.
 */
-template <typename Context>
-class dynamic_format_arg_store
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-    // Workaround a GCC template argument substitution bug.
-    : public basic_format_args<Context>
-#endif
-{
+template <typename Context> class dynamic_format_arg_store {
 private:
  using char_type = typename Context::char_type;

  template <typename T> struct need_copy {
    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, Context>::value;
+        detail::mapped_type_constant<T, char_type>::value;

    enum {
      value = !(detail::is_reference_wrapper<T>::value ||
@ -97,7 +90,7 @@ class dynamic_format_arg_store
  };

  template <typename T>
-  using stored_type = conditional_t<
+  using stored_t = conditional_t<
      std::is_convertible<T, std::basic_string<char_type>>::value &&
          !detail::is_reference_wrapper<T>::value,
      std::basic_string<char_type>, T>;
@ -112,41 +105,37 @@ class dynamic_format_arg_store

  friend class basic_format_args<Context>;

-  auto get_types() const -> unsigned long long {
-    return detail::is_unpacked_bit | data_.size() |
-           (named_info_.empty()
-                ? 0ULL
-                : static_cast<unsigned long long>(detail::has_named_args_bit));
-  }
-
  auto data() const -> const basic_format_arg<Context>* {
    return named_info_.empty() ? data_.data() : data_.data() + 1;
  }

  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(detail::make_arg<Context>(arg));
+    data_.emplace_back(arg);
  }

  template <typename T>
  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty()) {
-      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
-      data_.insert(data_.begin(), {zero_ptr, 0});
-    }
-    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    if (named_info_.empty())
+      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
+    data_.emplace_back(detail::unwrap(arg.value));
    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
      data->pop_back();
    };
    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
        guard{&data_, pop_one};
    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    data_[0] = {named_info_.data(), named_info_.size()};
    guard.release();
  }

 public:
  constexpr dynamic_format_arg_store() = default;

+  operator basic_format_args<Context>() const {
+    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
+                                      !named_info_.empty());
+  }
+
  /**
   * Adds an argument into the dynamic store for later passing to a formatting
   * function.
@ -164,7 +153,7 @@ class dynamic_format_arg_store
   */
  template <typename T> void push_back(const T& arg) {
    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
    else
      emplace_arg(detail::unwrap(arg));
  }
@ -200,7 +189,7 @@ class dynamic_format_arg_store
        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
    if (detail::const_check(need_copy<T>::value)) {
      emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
    } else {
      emplace_arg(fmt::arg(arg_name, arg.value));
    }
@ -210,14 +199,14 @@ class dynamic_format_arg_store
  void clear() {
    data_.clear();
    named_info_.clear();
-    dynamic_args_ = detail::dynamic_arg_list();
+    dynamic_args_ = {};
  }

  /// Reserves space to store at least `new_cap` arguments including
  /// `new_cap_named` named arguments.
  void reserve(size_t new_cap, size_t new_cap_named) {
    FMT_ASSERT(new_cap >= new_cap_named,
-               "Set of arguments includes set of named arguments");
+               "set of arguments includes set of named arguments");
    data_.reserve(new_cap);
    named_info_.reserve(new_cap_named);
  }
--- a/3rdparty/fmt/include/fmt/base.h
+++ b/3rdparty/fmt/include/fmt/base.h
--- a/3rdparty/fmt/include/fmt/chrono.h
+++ b/3rdparty/fmt/include/fmt/chrono.h
--- a/3rdparty/fmt/include/fmt/color.h
+++ b/3rdparty/fmt/include/fmt/color.h
@ -330,7 +330,7 @@ FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
 namespace detail {

 template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
+  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
                                  const char* esc) noexcept {
    // If we have a terminal color, we need to output another escape code
    // sequence.
@ -412,13 +412,13 @@ template <typename Char> struct ansi_color_escape {
 };

 template <typename Char>
-FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
+FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
    -> ansi_color_escape<Char> {
  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }

 template <typename Char>
-FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
+FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
    -> ansi_color_escape<Char> {
  return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
@ -434,36 +434,35 @@ template <typename Char> inline void reset_color(buffer<Char>& buffer) {
  buffer.append(reset_color.begin(), reset_color.end());
 }

-template <typename T> struct styled_arg : detail::view {
+template <typename T> struct styled_arg : view {
  const T& value;
  text_style style;
  styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };

 template <typename Char>
-void vformat_to(
-    buffer<Char>& buf, const text_style& ts, basic_string_view<Char> format_str,
-    basic_format_args<buffered_context<type_identity_t<Char>>> args) {
+void vformat_to(buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> fmt,
+                basic_format_args<buffered_context<Char>> args) {
  bool has_style = false;
  if (ts.has_emphasis()) {
    has_style = true;
-    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
    buf.append(emphasis.begin(), emphasis.end());
  }
  if (ts.has_foreground()) {
    has_style = true;
-    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    auto foreground = make_foreground_color<Char>(ts.get_foreground());
    buf.append(foreground.begin(), foreground.end());
  }
  if (ts.has_background()) {
    has_style = true;
-    auto background = detail::make_background_color<Char>(ts.get_background());
+    auto background = make_background_color<Char>(ts.get_background());
    buf.append(background.begin(), background.end());
  }
-  detail::vformat_to(buf, format_str, args, {});
-  if (has_style) detail::reset_color<Char>(buf);
+  vformat_to(buf, fmt, args);
+  if (has_style) reset_color<Char>(buf);
 }
-
 }  // namespace detail

 inline void vprint(FILE* f, const text_style& ts, string_view fmt,
@ -485,7 +484,7 @@ inline void vprint(FILE* f, const text_style& ts, string_view fmt,
 template <typename... T>
 void print(FILE* f, const text_style& ts, format_string<T...> fmt,
           T&&... args) {
-  vprint(f, ts, fmt, fmt::make_format_args(args...));
+  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
 }

 /**
@ -524,7 +523,7 @@ inline auto vformat(const text_style& ts, string_view fmt, format_args args)
 template <typename... T>
 inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
    -> std::string {
-  return fmt::vformat(ts, fmt, fmt::make_format_args(args...));
+  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
 }

 /// Formats a string with the given text_style and writes the output to `out`.
@ -551,7 +550,7 @@ template <typename OutputIt, typename... T,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
 inline auto format_to(OutputIt out, const text_style& ts,
                      format_string<T...> fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, ts, fmt, fmt::make_format_args(args...));
+  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
 }

 template <typename T, typename Char>
@ -560,31 +559,30 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    const auto& ts = arg.style;
-    const auto& value = arg.value;
    auto out = ctx.out();

    bool has_style = false;
    if (ts.has_emphasis()) {
      has_style = true;
      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-      out = std::copy(emphasis.begin(), emphasis.end(), out);
+      out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
    }
    if (ts.has_foreground()) {
      has_style = true;
      auto foreground =
          detail::make_foreground_color<Char>(ts.get_foreground());
-      out = std::copy(foreground.begin(), foreground.end(), out);
+      out = detail::copy<Char>(foreground.begin(), foreground.end(), out);
    }
    if (ts.has_background()) {
      has_style = true;
      auto background =
          detail::make_background_color<Char>(ts.get_background());
-      out = std::copy(background.begin(), background.end(), out);
+      out = detail::copy<Char>(background.begin(), background.end(), out);
    }
-    out = formatter<T, Char>::format(value, ctx);
+    out = formatter<T, Char>::format(arg.value, ctx);
    if (has_style) {
      auto reset_color = string_view("\x1b[0m");
-      out = std::copy(reset_color.begin(), reset_color.end(), out);
+      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
    }
    return out;
  }
--- a/3rdparty/fmt/include/fmt/compile.h
+++ b/3rdparty/fmt/include/fmt/compile.h
@ -21,12 +21,6 @@ FMT_EXPORT class compiled_string {};

 namespace detail {

-template <typename T, typename InputIt>
-FMT_CONSTEXPR inline auto copy(InputIt begin, InputIt end, counting_iterator it)
-    -> counting_iterator {
-  return it + (end - begin);
-}
-
 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};

@ -42,14 +36,13 @@ struct is_compiled_string : std::is_base_of<compiled_string, S> {};
 *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
 */
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string, explicit)
+#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
 #else
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif

 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <typename Char, size_t N,
-          fmt::detail_exported::fixed_string<Char, N> Str>
+template <typename Char, size_t N, fmt::detail::fixed_string<Char, N> Str>
 struct udl_compiled_string : compiled_string {
  using char_type = Char;
  explicit constexpr operator basic_string_view<char_type>() const {
@ -77,6 +70,29 @@ constexpr const auto& get([[maybe_unused]] const T& first,
    return detail::get<N - 1>(rest...);
 }

+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <int N, typename T, typename... Args, typename Char>
+constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+  if constexpr (is_static_named_arg<T>()) {
+    if (name == T::name) return N;
+  }
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<N + 1, Args...>(name);
+  (void)name;  // Workaround an MSVC bug about "unused" parameter.
+  return -1;
+}
+#  endif
+
+template <typename... Args, typename Char>
+FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<0, Args...>(name);
+#  endif
+  (void)name;
+  return -1;
+}
+
 template <typename Char, typename... Args>
 constexpr int get_arg_index_by_name(basic_string_view<Char> name,
                                    type_list<Args...>) {
@ -149,8 +165,9 @@ template <typename Char, typename T, int N> struct field {
    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
      auto s = basic_string_view<Char>(arg);
      return copy<Char>(s.begin(), s.end(), out);
+    } else {
+      return write<Char>(out, arg);
    }
-    return write<Char>(out, arg);
  }
 };

@ -275,6 +292,7 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 }

 template <typename Char> struct arg_id_handler {
+  arg_id_kind kind;
  arg_ref<Char> arg_id;

  constexpr int on_auto() {
@ -282,25 +300,28 @@ template <typename Char> struct arg_id_handler {
    return 0;
  }
  constexpr int on_index(int id) {
+    kind = arg_id_kind::index;
    arg_id = arg_ref<Char>(id);
    return 0;
  }
  constexpr int on_name(basic_string_view<Char> id) {
+    kind = arg_id_kind::name;
    arg_id = arg_ref<Char>(id);
    return 0;
  }
 };

 template <typename Char> struct parse_arg_id_result {
+  arg_id_kind kind;
  arg_ref<Char> arg_id;
  const Char* arg_id_end;
 };

 template <int ID, typename Char>
 constexpr auto parse_arg_id(const Char* begin, const Char* end) {
-  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
  auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
 }

 template <typename T, typename Enable = void> struct field_type {
@ -363,18 +384,18 @@ constexpr auto compile_format_string(S fmt) {
      constexpr char_type c =
          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
      static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+      if constexpr (arg_id_result.kind == arg_id_kind::index) {
        static_assert(
            ID == manual_indexing_id || ID == 0,
            "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        constexpr auto arg_index = arg_id_result.arg_id.index;
        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
                                                 Args, arg_id_end_pos,
                                                 arg_index, manual_indexing_id>(
            fmt);
-      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
        constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
        if constexpr (arg_index >= 0) {
          constexpr auto next_id =
              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
@ -383,8 +404,7 @@ constexpr auto compile_format_string(S fmt) {
              arg_index, next_id>(fmt);
        } else if constexpr (c == '}') {
          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
-              fmt);
+              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
        } else if constexpr (c == ':') {
          return unknown_format();  // no type info for specs parsing
        }
@ -496,7 +516,9 @@ template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
    -> size_t {
-  return fmt::format_to(detail::counting_iterator(), fmt, args...).count();
+  auto buf = detail::counting_buffer<>();
+  fmt::format_to(appender(buf), fmt, args...);
+  return buf.count();
 }

 template <typename S, typename... Args,
@ -515,7 +537,7 @@ void print(const S& fmt, const Args&... args) {

 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
+template <detail::fixed_string Str> constexpr auto operator""_cf() {
  using char_t = remove_cvref_t<decltype(Str.data[0])>;
  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
                                     Str>();
--- a/3rdparty/fmt/include/fmt/format-inl.h
+++ b/3rdparty/fmt/include/fmt/format-inl.h
@ -14,10 +14,6 @@
 #  include <climits>
 #  include <cmath>
 #  include <exception>
-
-#  if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#    include <locale>
-#  endif
 #endif

 #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE)
@ -26,16 +22,22 @@

 #include "format.h"

+#if FMT_USE_LOCALE
+#  include <locale>
+#endif
+
+#ifndef FMT_FUNC
+#  define FMT_FUNC
+#endif
+
 FMT_BEGIN_NAMESPACE
 namespace detail {

 FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
  // Use unchecked std::fprintf to avoid triggering another assertion when
-  // writing to stderr fails
-  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
-  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
-  // code pass.
-  std::terminate();
+  // writing to stderr fails.
+  fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
+  abort();
 }

 FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
@ -61,86 +63,93 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
  FMT_ASSERT(out.size() <= inline_buffer_size, "");
 }

-FMT_FUNC void report_error(format_func func, int error_code,
-                           const char* message) noexcept {
+FMT_FUNC void do_report_error(format_func func, int error_code,
+                              const char* message) noexcept {
  memory_buffer full_message;
  func(full_message, error_code, message);
-  // Don't use fwrite_fully because the latter may throw.
+  // Don't use fwrite_all because the latter may throw.
  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
    std::fputc('\n', stderr);
 }

 // A wrapper around fwrite that throws on error.
-inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
+inline void fwrite_all(const void* ptr, size_t count, FILE* stream) {
  size_t written = std::fwrite(ptr, 1, count, stream);
  if (written < count)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }

-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template <typename Locale>
+#if FMT_USE_LOCALE
+using std::locale;
+using std::numpunct;
+using std::use_facet;
+
+template <typename Locale, enable_if_t<(sizeof(Locale::collate) != 0), int>>
 locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
+  static_assert(std::is_same<Locale, locale>::value, "");
 }
+#else
+struct locale {};
+template <typename Char> struct numpunct {
+  auto grouping() const -> std::string { return "\03"; }
+  auto thousands_sep() const -> Char { return ','; }
+  auto decimal_point() const -> Char { return '.'; }
+};
+template <typename Facet> Facet use_facet(locale) { return {}; }
+#endif  // FMT_USE_LOCALE

 template <typename Locale> auto locale_ref::get() const -> Locale {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
+  static_assert(std::is_same<Locale, locale>::value, "");
+#if FMT_USE_LOCALE
+  if (locale_) return *static_cast<const locale*>(locale_);
+#endif
+  return locale();
 }

 template <typename Char>
 FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
-  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
+  auto&& facet = use_facet<numpunct<Char>>(loc.get<locale>());
  auto grouping = facet.grouping();
  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
  return {std::move(grouping), thousands_sep};
 }
 template <typename Char>
 FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
+  return use_facet<numpunct<Char>>(loc.get<locale>()).decimal_point();
 }
-#else
-template <typename Char>
-FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
-  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
-  return '.';
-}
-#endif

+#if FMT_USE_LOCALE
 FMT_FUNC auto write_loc(appender out, loc_value value,
                        const format_specs& specs, locale_ref loc) -> bool {
-#ifdef FMT_STATIC_THOUSANDS_SEPARATOR
-  value.visit(loc_writer<>{
-      out, specs, std::string(1, FMT_STATIC_THOUSANDS_SEPARATOR), "\3", "."});
-  return true;
-#else
  auto locale = loc.get<std::locale>();
  // We cannot use the num_put<char> facet because it may produce output in
  // a wrong encoding.
  using facet = format_facet<std::locale>;
  if (std::has_facet<facet>(locale))
-    return std::use_facet<facet>(locale).put(out, value, specs);
+    return use_facet<facet>(locale).put(out, value, specs);
  return facet(locale).put(out, value, specs);
-#endif
 }
+#endif
 }  // namespace detail

 FMT_FUNC void report_error(const char* message) {
-  FMT_THROW(format_error(message));
+#if FMT_USE_EXCEPTIONS
+  throw format_error(message);
+#else
+  fputs(message, stderr);
+  abort();
+#endif
 }

 template <typename Locale> typename Locale::id format_facet<Locale>::id;

-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
-  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
-  grouping_ = numpunct.grouping();
-  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
+  auto& np = detail::use_facet<detail::numpunct<char>>(loc);
+  grouping_ = np.grouping();
+  if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep());
 }

+#if FMT_USE_LOCALE
 template <>
 FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
    appender out, loc_value val, const format_specs& specs) const -> bool {
@ -1425,7 +1434,7 @@ FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,

 FMT_FUNC void report_system_error(int error_code,
                                  const char* message) noexcept {
-  report_error(format_system_error, error_code, message);
+  do_report_error(format_system_error, error_code, message);
 }

 FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
@ -1438,6 +1447,15 @@ FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {

 namespace detail {

+FMT_FUNC void vformat_to(buffer<char>& buf, string_view fmt, format_args args,
+                         locale_ref loc) {
+  auto out = appender(buf);
+  if (fmt.size() == 2 && equal2(fmt.data(), "{}"))
+    return args.get(0).visit(default_arg_formatter<char>{out});
+  parse_format_string(
+      fmt, format_handler<char>{parse_context<char>(fmt), {out, args, loc}});
+}
+
 template <typename T> struct span {
  T* data;
  size_t size;
@ -1508,6 +1526,7 @@ template <typename F> class glibc_file : public file_base<F> {
  void init_buffer() {
    if (this->file_->_IO_write_ptr) return;
    // Force buffer initialization by placing and removing a char in a buffer.
+    assume(this->file_->_IO_write_ptr >= this->file_->_IO_write_end);
    putc_unlocked(0, this->file_);
    --this->file_->_IO_write_ptr;
  }
@ -1615,7 +1634,7 @@ template <typename F> class fallback_file : public file_base<F> {
 };

 #ifndef FMT_USE_FALLBACK_FILE
-#  define FMT_USE_FALLBACK_FILE 1
+#  define FMT_USE_FALLBACK_FILE 0
 #endif

 template <typename F,
@ -1692,7 +1711,7 @@ FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args,
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, fmt, args);
  if (newline) buffer.push_back('\n');
-  fwrite_fully(buffer.data(), buffer.size(), f);
+  fwrite_all(buffer.data(), buffer.size(), f);
 }
 #endif

@ -1704,7 +1723,7 @@ FMT_FUNC void print(std::FILE* f, string_view text) {
    if (write_console(fd, text)) return;
  }
 #endif
-  fwrite_fully(text.data(), text.size(), f);
+  fwrite_all(text.data(), text.size(), f);
 }
 }  // namespace detail

--- a/3rdparty/fmt/include/fmt/format.h
+++ b/3rdparty/fmt/include/fmt/format.h
--- a/3rdparty/fmt/include/fmt/os.h
+++ b/3rdparty/fmt/include/fmt/os.h
@ -118,7 +118,7 @@ FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                  const char* message) noexcept;
 }

-FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
                                         format_args args);

 /**
@ -146,10 +146,10 @@ FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
 *                                "cannot open file '{}'", filename);
 *     }
 */
-template <typename... Args>
-std::system_error windows_error(int error_code, string_view message,
-                                const Args&... args) {
-  return vwindows_error(error_code, message, fmt::make_format_args(args...));
+template <typename... T>
+auto windows_error(int error_code, string_view message, const T&... args)
+    -> std::system_error {
+  return vwindows_error(error_code, message, vargs<T...>{{args...}});
 }

 // Reports a Windows error without throwing an exception.
@ -164,8 +164,8 @@ inline auto system_category() noexcept -> const std::error_category& {
 // std::system is not available on some platforms such as iOS (#2248).
 #ifdef __OSX__
 template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& format_str, Args&&... args) {
-  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+void say(const S& fmt, Args&&... args) {
+  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
 }
 #endif

@ -176,24 +176,24 @@ class buffered_file {

  friend class file;

-  explicit buffered_file(FILE* f) : file_(f) {}
+  inline explicit buffered_file(FILE* f) : file_(f) {}

 public:
  buffered_file(const buffered_file&) = delete;
  void operator=(const buffered_file&) = delete;

  // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() noexcept : file_(nullptr) {}
+  inline buffered_file() noexcept : file_(nullptr) {}

  // Destroys the object closing the file it represents if any.
  FMT_API ~buffered_file() noexcept;

 public:
-  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
    other.file_ = nullptr;
  }

-  auto operator=(buffered_file&& other) -> buffered_file& {
+  inline auto operator=(buffered_file&& other) -> buffered_file& {
    close();
    file_ = other.file_;
    other.file_ = nullptr;
@ -207,13 +207,13 @@ class buffered_file {
  FMT_API void close();

  // Returns the pointer to a FILE object representing this file.
-  auto get() const noexcept -> FILE* { return file_; }
+  inline auto get() const noexcept -> FILE* { return file_; }

  FMT_API auto descriptor() const -> int;

  template <typename... T>
  inline void print(string_view fmt, const T&... args) {
-    const auto& vargs = fmt::make_format_args(args...);
+    fmt::vargs<T...> vargs = {{args...}};
    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
                               : fmt::vprint(file_, fmt, vargs);
  }
@ -248,7 +248,7 @@ class FMT_API file {
  };

  // Constructs a file object which doesn't represent any file.
-  file() noexcept : fd_(-1) {}
+  inline file() noexcept : fd_(-1) {}

  // Opens a file and constructs a file object representing this file.
  file(cstring_view path, int oflag);
@ -257,10 +257,10 @@ class FMT_API file {
  file(const file&) = delete;
  void operator=(const file&) = delete;

-  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }

  // Move assignment is not noexcept because close may throw.
-  auto operator=(file&& other) -> file& {
+  inline auto operator=(file&& other) -> file& {
    close();
    fd_ = other.fd_;
    other.fd_ = -1;
@ -271,7 +271,7 @@ class FMT_API file {
  ~file() noexcept;

  // Returns the file descriptor.
-  auto descriptor() const noexcept -> int { return fd_; }
+  inline auto descriptor() const noexcept -> int { return fd_; }

  // Closes the file.
  void close();
@ -324,9 +324,9 @@ auto getpagesize() -> long;
 namespace detail {

 struct buffer_size {
-  buffer_size() = default;
+  constexpr buffer_size() = default;
  size_t value = 0;
-  auto operator=(size_t val) const -> buffer_size {
+  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
    auto bs = buffer_size();
    bs.value = val;
    return bs;
@ -337,7 +337,7 @@ struct ostream_params {
  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;

-  ostream_params() {}
+  constexpr ostream_params() {}

  template <typename... T>
  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
@ -358,59 +358,47 @@ struct ostream_params {
 #  endif
 };

-class file_buffer final : public buffer<char> {
+}  // namespace detail
+
+FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
+
+/// A fast buffered output stream for writing from a single thread. Writing from
+/// multiple threads without external synchronization may result in a data race.
+class FMT_API ostream : private detail::buffer<char> {
 private:
  file file_;

-  FMT_API static void grow(buffer<char>& buf, size_t);
+  ostream(cstring_view path, const detail::ostream_params& params);
+
+  static void grow(buffer<char>& buf, size_t);

 public:
-  FMT_API file_buffer(cstring_view path, const ostream_params& params);
-  FMT_API file_buffer(file_buffer&& other) noexcept;
-  FMT_API ~file_buffer();
+  ostream(ostream&& other) noexcept;
+  ~ostream();

-  void flush() {
+  operator writer() {
+    detail::buffer<char>& buf = *this;
+    return buf;
+  }
+
+  inline void flush() {
    if (size() == 0) return;
    file_.write(data(), size() * sizeof(data()[0]));
    clear();
  }

-  void close() {
-    flush();
-    file_.close();
-  }
-};
-
-}  // namespace detail
-
-constexpr auto buffer_size = detail::buffer_size();
-
-/// A fast output stream for writing from a single thread. Writing from
-/// multiple threads without external synchronization may result in a data race.
-class FMT_API ostream {
- private:
-  FMT_MSC_WARNING(suppress : 4251)
-  detail::file_buffer buffer_;
-
-  ostream(cstring_view path, const detail::ostream_params& params)
-      : buffer_(path, params) {}
-
- public:
-  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
-
-  ~ostream();
-
-  void flush() { buffer_.flush(); }
-
  template <typename... T>
  friend auto output_file(cstring_view path, T... params) -> ostream;

-  void close() { buffer_.close(); }
+  inline void close() {
+    flush();
+    file_.close();
+  }

  /// Formats `args` according to specifications in `fmt` and writes the
  /// output to the file.
  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(appender(buffer_), fmt, fmt::make_format_args(args...));
+    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
  }
 };

--- a/3rdparty/fmt/include/fmt/ostream.h
+++ b/3rdparty/fmt/include/fmt/ostream.h
@ -41,47 +41,12 @@ template class file_access<file_access_tag, std::filebuf,
 auto get_file(std::filebuf&) -> FILE*;
 #endif

-inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
-    -> bool {
-  FILE* f = nullptr;
-#if FMT_MSC_VERSION && FMT_USE_RTTI
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    f = get_file(*buf);
-  else
-    return false;
-#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
-  auto* rdbuf = os.rdbuf();
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    f = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    f = fbuf->file();
-  else
-    return false;
-#else
-  ignore_unused(os, data, f);
-#endif
-#ifdef _WIN32
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      return write_console(fd, data);
-    }
-  }
-#endif
-  return false;
-}
-inline auto write_ostream_unicode(std::wostream&,
-                                  fmt::basic_string_view<wchar_t>) -> bool {
-  return false;
-}
-
 // Write the content of buf to os.
 // It is a separate function rather than a part of vprint to simplify testing.
 template <typename Char>
 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  const Char* buf_data = buf.data();
-  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
  unsigned_streamsize size = buf.size();
  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
  do {
@ -92,21 +57,9 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  } while (size != 0);
 }

-template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value) {
-  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
-  auto&& output = std::basic_ostream<Char>(&format_buf);
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-  output.imbue(std::locale::classic());  // The default is always unlocalized.
-#endif
-  output << value;
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-}
-
 template <typename T> struct streamed_view {
  const T& value;
 };
-
 }  // namespace detail

 // Formats an object of type T that has an overloaded ostream operator<<.
@ -117,7 +70,11 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
  template <typename T, typename Context>
  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
    auto buffer = basic_memory_buffer<Char>();
-    detail::format_value(buffer, value);
+    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
+    auto&& output = std::basic_ostream<Char>(&formatbuf);
+    output.imbue(std::locale::classic());  // The default is always unlocalized.
+    output << value;
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
@ -148,24 +105,30 @@ constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
  return {value};
 }

-namespace detail {
-
-inline void vprint_directly(std::ostream& os, string_view format_str,
-                            format_args args) {
+inline void vprint(std::ostream& os, string_view fmt, format_args args) {
  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, format_str, args);
-  detail::write_buffer(os, buffer);
-}
-
-}  // namespace detail
-
-FMT_EXPORT template <typename Char>
-void vprint(std::basic_ostream<Char>& os,
-            basic_string_view<type_identity_t<Char>> format_str,
-            typename detail::vformat_args<Char>::type args) {
-  auto buffer = basic_memory_buffer<Char>();
-  detail::vformat_to(buffer, format_str, args);
-  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
+  detail::vformat_to(buffer, fmt, args);
+  FILE* f = nullptr;
+#if FMT_MSC_VERSION && FMT_USE_RTTI
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    f = detail::get_file(*buf);
+#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
+  auto* rdbuf = os.rdbuf();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    f = fbuf->file();
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
+    }
+  }
+#endif
+  detail::ignore_unused(f);
  detail::write_buffer(os, buffer);
 }

@ -178,19 +141,11 @@ void vprint(std::basic_ostream<Char>& os,
 */
 FMT_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  const auto& vargs = fmt::make_format_args(args...);
-  if (detail::use_utf8())
-    vprint(os, fmt, vargs);
-  else
-    detail::vprint_directly(os, fmt, vargs);
-}
-
-FMT_EXPORT
-template <typename... Args>
-void print(std::wostream& os,
-           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
-           Args&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
+  fmt::vargs<T...> vargs = {{args...}};
+  if (detail::use_utf8) return vprint(os, fmt.str, vargs);
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt.str, vargs);
+  detail::write_buffer(os, buffer);
 }

 FMT_EXPORT template <typename... T>
@ -198,14 +153,6 @@ void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }

-FMT_EXPORT
-template <typename... Args>
-void println(std::wostream& os,
-             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
-             Args&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
-}
-
 FMT_END_NAMESPACE

 #endif  // FMT_OSTREAM_H_
--- a/3rdparty/fmt/include/fmt/printf.h
+++ b/3rdparty/fmt/include/fmt/printf.h
@ -33,8 +33,9 @@ template <typename Char> class basic_printf_context {

 public:
  using char_type = Char;
-  using parse_context_type = basic_format_parse_context<Char>;
+  using parse_context_type = parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;
+  enum { builtin_types = 1 };

  /// Constructs a `printf_context` object. References to the arguments are
  /// stored in the context object so make sure they have appropriate lifetimes.
@ -54,6 +55,23 @@ template <typename Char> class basic_printf_context {

 namespace detail {

+// Return the result via the out param to workaround gcc bug 77539.
+template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
+FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
+  for (out = first; out != last; ++out) {
+    if (*out == value) return true;
+  }
+  return false;
+}
+
+template <>
+inline auto find<false, char>(const char* first, const char* last, char value,
+                              const char*& out) -> bool {
+  out =
+      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
+  return out != nullptr;
+}
+
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
@ -61,7 +79,7 @@ template <bool IsSigned> struct int_checker {
    unsigned max = to_unsigned(max_value<int>());
    return value <= max;
  }
-  static auto fits_in_int(bool) -> bool { return true; }
+  inline static auto fits_in_int(bool) -> bool { return true; }
 };

 template <> struct int_checker<true> {
@ -69,7 +87,7 @@ template <> struct int_checker<true> {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
-  static auto fits_in_int(int) -> bool { return true; }
+  inline static auto fits_in_int(int) -> bool { return true; }
 };

 struct printf_precision_handler {
@ -127,25 +145,19 @@ template <typename T, typename Context> class arg_converter {
    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
    if (const_check(sizeof(target_type) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        auto n = static_cast<int>(static_cast<target_type>(value));
-        arg_ = detail::make_arg<Context>(n);
-      } else {
-        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
-        arg_ = detail::make_arg<Context>(n);
-      }
+      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+      if (is_signed)
+        arg_ = static_cast<int>(static_cast<target_type>(value));
+      else
+        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
    } else {
-      if (is_signed) {
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        auto n = static_cast<long long>(value);
-        arg_ = detail::make_arg<Context>(n);
-      } else {
-        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
-        arg_ = detail::make_arg<Context>(n);
-      }
+      // glibc's printf doesn't sign extend arguments of smaller types:
+      //   std::printf("%lld", -42);  // prints "4294967254"
+      // but we don't have to do the same because it's a UB.
+      if (is_signed)
+        arg_ = static_cast<long long>(value);
+      else
+        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
    }
  }

@ -172,8 +184,7 @@ template <typename Context> class char_converter {

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  void operator()(T value) {
-    auto c = static_cast<typename Context::char_type>(value);
-    arg_ = detail::make_arg<Context>(c);
+    arg_ = static_cast<typename Context::char_type>(value);
  }

  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@ -194,13 +205,13 @@ class printf_width_handler {
  format_specs& specs_;

 public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}

  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  auto operator()(T value) -> unsigned {
    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
    if (detail::is_negative(value)) {
-      specs_.align = align::left;
+      specs_.set_align(align::left);
      width = 0 - width;
    }
    unsigned int_max = to_unsigned(max_value<int>());
@ -234,69 +245,74 @@ class printf_arg_formatter : public arg_formatter<Char> {

  void write_null_pointer(bool is_string = false) {
    auto s = this->specs;
-    s.type = presentation_type::none;
+    s.set_type(presentation_type::none);
    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
  }

+  template <typename T> void write(T value) {
+    detail::write<Char>(this->out, value, this->specs, this->locale);
+  }
+
 public:
  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
                       context_type& ctx)
      : base(make_arg_formatter(iter, s)), context_(ctx) {}

-  void operator()(monostate value) { base::operator()(value); }
+  void operator()(monostate value) { write(value); }

  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
  void operator()(T value) {
    // MSVC2013 fails to compile separate overloads for bool and Char so use
    // std::is_same instead.
    if (!std::is_same<T, Char>::value) {
-      base::operator()(value);
+      write(value);
      return;
    }
    format_specs s = this->specs;
-    if (s.type != presentation_type::none && s.type != presentation_type::chr) {
+    if (s.type() != presentation_type::none &&
+        s.type() != presentation_type::chr) {
      return (*this)(static_cast<int>(value));
    }
-    s.sign = sign::none;
-    s.alt = false;
-    s.fill = ' ';  // Ignore '0' flag for char types.
+    s.set_sign(sign::none);
+    s.clear_alt();
+    s.set_fill(' ');  // Ignore '0' flag for char types.
    // align::numeric needs to be overwritten here since the '0' flag is
    // ignored for non-numeric types
-    if (s.align == align::none || s.align == align::numeric)
-      s.align = align::right;
-    write<Char>(this->out, static_cast<Char>(value), s);
+    if (s.align() == align::none || s.align() == align::numeric)
+      s.set_align(align::right);
+    detail::write<Char>(this->out, static_cast<Char>(value), s);
  }

  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
  void operator()(T value) {
-    base::operator()(value);
+    write(value);
  }

  void operator()(const char* value) {
    if (value)
-      base::operator()(value);
+      write(value);
    else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
  }

  void operator()(const wchar_t* value) {
    if (value)
-      base::operator()(value);
+      write(value);
    else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
  }

-  void operator()(basic_string_view<Char> value) { base::operator()(value); }
+  void operator()(basic_string_view<Char> value) { write(value); }

  void operator()(const void* value) {
    if (value)
-      base::operator()(value);
+      write(value);
    else
      write_null_pointer();
  }

  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx = basic_format_parse_context<Char>({});
+    auto parse_ctx = parse_context<Char>({});
    handle.format(parse_ctx, context_);
  }
 };
@ -305,23 +321,14 @@ template <typename Char>
 void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
-    case '-':
-      specs.align = align::left;
-      break;
-    case '+':
-      specs.sign = sign::plus;
-      break;
-    case '0':
-      specs.fill = '0';
-      break;
+    case '-': specs.set_align(align::left); break;
+    case '+': specs.set_sign(sign::plus); break;
+    case '0': specs.set_fill('0'); break;
    case ' ':
-      if (specs.sign != sign::plus) specs.sign = sign::space;
+      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
      break;
-    case '#':
-      specs.alt = true;
-      break;
-    default:
-      return;
+    case '#': specs.set_alt(); break;
+    default:  return;
    }
  }
 }
@ -339,7 +346,7 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
      ++it;
      arg_index = value != -1 ? value : max_value<int>();
    } else {
-      if (c == '0') specs.fill = '0';
+      if (c == '0') specs.set_fill('0');
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
@ -369,43 +376,22 @@ inline auto parse_printf_presentation_type(char c, type t, bool& upper)
  using pt = presentation_type;
  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
  switch (c) {
-  case 'd':
-    return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o':
-    return in(t, integral_set) ? pt::oct : pt::none;
-  case 'X':
-    upper = true;
-    FMT_FALLTHROUGH;
-  case 'x':
-    return in(t, integral_set) ? pt::hex : pt::none;
-  case 'E':
-    upper = true;
-    FMT_FALLTHROUGH;
-  case 'e':
-    return in(t, float_set) ? pt::exp : pt::none;
-  case 'F':
-    upper = true;
-    FMT_FALLTHROUGH;
-  case 'f':
-    return in(t, float_set) ? pt::fixed : pt::none;
-  case 'G':
-    upper = true;
-    FMT_FALLTHROUGH;
-  case 'g':
-    return in(t, float_set) ? pt::general : pt::none;
-  case 'A':
-    upper = true;
-    FMT_FALLTHROUGH;
-  case 'a':
-    return in(t, float_set) ? pt::hexfloat : pt::none;
-  case 'c':
-    return in(t, integral_set) ? pt::chr : pt::none;
-  case 's':
-    return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p':
-    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:
-    return pt::none;
+  case 'd': return in(t, integral_set) ? pt::dec : pt::none;
+  case 'o': return in(t, integral_set) ? pt::oct : pt::none;
+  case 'X': upper = true; FMT_FALLTHROUGH;
+  case 'x': return in(t, integral_set) ? pt::hex : pt::none;
+  case 'E': upper = true; FMT_FALLTHROUGH;
+  case 'e': return in(t, float_set) ? pt::exp : pt::none;
+  case 'F': upper = true; FMT_FALLTHROUGH;
+  case 'f': return in(t, float_set) ? pt::fixed : pt::none;
+  case 'G': upper = true; FMT_FALLTHROUGH;
+  case 'g': return in(t, float_set) ? pt::general : pt::none;
+  case 'A': upper = true; FMT_FALLTHROUGH;
+  case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;
+  case 'c': return in(t, integral_set) ? pt::chr : pt::none;
+  case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;
+  case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
+  default:  return pt::none;
  }
 }

@ -415,7 +401,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
  using iterator = basic_appender<Char>;
  auto out = iterator(buf);
  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = basic_format_parse_context<Char>(format);
+  auto parse_ctx = parse_context<Char>(format);

  // Returns the argument with specified index or, if arg_index is -1, the next
  // argument.
@ -444,7 +430,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));

    auto specs = format_specs();
-    specs.align = align::right;
+    specs.set_align(align::right);

    // Parse argument index, flags and width.
    int arg_index = parse_header(it, end, specs, get_arg);
@ -468,9 +454,9 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    auto arg = get_arg(arg_index);
    // For d, i, o, u, x, and X conversion specifiers, if a precision is
    // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && arg.is_integral()) {
+    if (specs.precision >= 0 && is_integral_type(arg.type())) {
      // Ignore '0' for non-numeric types or if '-' present.
-      specs.fill = ' ';
+      specs.set_fill(' ');
    }
    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
      auto str = arg.visit(get_cstring<Char>());
@ -478,15 +464,16 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
      auto nul = std::find(str, str_end, Char());
      auto sv = basic_string_view<Char>(
          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-      arg = make_arg<basic_printf_context<Char>>(sv);
+      arg = sv;
    }
-    if (specs.alt && arg.visit(is_zero_int())) specs.alt = false;
-    if (specs.fill.template get<Char>() == '0') {
-      if (arg.is_arithmetic() && specs.align != align::left)
-        specs.align = align::numeric;
-      else
-        specs.fill = ' ';  // Ignore '0' flag for non-numeric types or if '-'
-                           // flag is also present.
+    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
+    if (specs.fill_unit<Char>() == '0') {
+      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
+        specs.set_align(align::numeric);
+      } else {
+        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
+        specs.set_fill(' ');
+      }
    }

    // Parse length and convert the argument to the required type.
@ -511,44 +498,34 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        convert_arg<long>(arg, t);
      }
      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, t);
-      break;
-    case 'z':
-      convert_arg<size_t>(arg, t);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, t);
-      break;
+    case 'j': convert_arg<intmax_t>(arg, t); break;
+    case 'z': convert_arg<size_t>(arg, t); break;
+    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
    case 'L':
      // printf produces garbage when 'L' is omitted for long double, no
      // need to do the same.
      break;
-    default:
-      --it;
-      convert_arg<void>(arg, c);
+    default: --it; convert_arg<void>(arg, c);
    }

    // Parse type.
    if (it == end) report_error("invalid format string");
    char type = static_cast<char>(*it++);
-    if (arg.is_integral()) {
+    if (is_integral_type(arg.type())) {
      // Normalize type.
      switch (type) {
      case 'i':
-      case 'u':
-        type = 'd';
-        break;
+      case 'u': type = 'd'; break;
      case 'c':
        arg.visit(char_converter<basic_printf_context<Char>>(arg));
        break;
      }
    }
    bool upper = false;
-    specs.type = parse_printf_presentation_type(type, arg.type(), upper);
-    if (specs.type == presentation_type::none)
+    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
+    if (specs.type() == presentation_type::none)
      report_error("invalid format specifier");
-    specs.upper = upper;
+    if (upper) specs.set_upper();

    start = it;

@ -583,7 +560,7 @@ inline auto vsprintf(basic_string_view<Char> fmt,
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
  detail::vprintf(buf, fmt, args);
-  return to_string(buf);
+  return {buf.data(), buf.size()};
 }

 /**
@ -594,7 +571,7 @@ inline auto vsprintf(basic_string_view<Char> fmt,
 *
 *     std::string message = fmt::sprintf("The answer is %d", 42);
 */
-template <typename S, typename... T, typename Char = char_t<S>>
+template <typename S, typename... T, typename Char = detail::char_t<S>>
 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  return vsprintf(detail::to_string_view(fmt),
                  fmt::make_format_args<basic_printf_context<Char>>(args...));
@ -619,7 +596,7 @@ inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
 *
 *     fmt::fprintf(stderr, "Don't %s!", "panic");
 */
-template <typename S, typename... T, typename Char = char_t<S>>
+template <typename S, typename... T, typename Char = detail::char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  return vfprintf(f, detail::to_string_view(fmt),
                  make_printf_args<Char>(args...));
--- a/3rdparty/fmt/include/fmt/ranges.h
+++ b/3rdparty/fmt/include/fmt/ranges.h
@ -44,18 +44,6 @@ template <typename T> class is_set {
      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
 };

-template <typename... Ts> struct conditional_helper {};
-
-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
-
-#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
-
-#  define FMT_DECLTYPE_RETURN(val)  \
-    ->decltype(val) { return val; } \
-    static_assert(                  \
-        true, "")  // This makes it so that a semicolon is required after the
-                   // macro, which helps clang-format handle the formatting.
-
 // C array overload
 template <typename T, std::size_t N>
 auto range_begin(const T (&arr)[N]) -> const T* {
@ -76,9 +64,13 @@ struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),

 // Member function overloads.
 template <typename T>
-auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+auto range_begin(T&& rng) -> decltype(static_cast<T&&>(rng).begin()) {
+  return static_cast<T&&>(rng).begin();
+}
 template <typename T>
-auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+auto range_end(T&& rng) -> decltype(static_cast<T&&>(rng).end()) {
+  return static_cast<T&&>(rng).end();
+}

 // ADL overloads. Only participate in overload resolution if member functions
 // are not found.
@ -115,17 +107,16 @@ struct has_mutable_begin_end<
              // SFINAE properly unless there are distinct types
              int>> : std::true_type {};

+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
 template <typename T>
 struct is_range_<T, void>
    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
                                    has_mutable_begin_end<T>::value)> {};
-#  undef FMT_DECLTYPE_RETURN
-#endif

 // tuple_size and tuple_element check.
 template <typename T> class is_tuple_like_ {
-  template <typename U>
-  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename U, typename V = typename std::remove_cv<U>::type>
+  static auto check(U* p) -> decltype(std::tuple_size<V>::value, 0);
  template <typename> static void check(...);

 public:
@ -266,12 +257,12 @@ template <range_format K>
 using range_format_constant = std::integral_constant<range_format, K>;

 // These are not generic lambdas for compatibility with C++11.
-template <typename ParseContext> struct parse_empty_specs {
+template <typename Char> struct parse_empty_specs {
  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
    f.parse(ctx);
    detail::maybe_set_debug_format(f, true);
  }
-  ParseContext& ctx;
+  parse_context<Char>& ctx;
 };
 template <typename FormatContext> struct format_tuple_element {
  using char_type = typename FormatContext::char_type;
@ -327,11 +318,17 @@ struct formatter<Tuple, Char,
    closing_bracket_ = close;
  }

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    auto it = ctx.begin();
-    if (it != ctx.end() && *it != '}') report_error("invalid format specifier");
-    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
+    auto end = ctx.end();
+    if (it != end && detail::to_ascii(*it) == 'n') {
+      ++it;
+      set_brackets({}, {});
+      set_separator({});
+    }
+    if (it != end && *it != '}') report_error("invalid format specifier");
+    ctx.advance_to(it);
+    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
    return it;
  }

@ -352,27 +349,9 @@ template <typename T, typename Char> struct is_range {
 };

 namespace detail {
-template <typename Context> struct range_mapper {
-  using mapper = arg_mapper<Context>;
-
-  template <typename T,
-            FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
-  static auto map(T&& value) -> T&& {
-    return static_cast<T&&>(value);
-  }
-  template <typename T,
-            FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
-  static auto map(T&& value)
-      -> decltype(mapper().map(static_cast<T&&>(value))) {
-    return mapper().map(static_cast<T&&>(value));
-  }
-};

 template <typename Char, typename Element>
-using range_formatter_type =
-    formatter<remove_cvref_t<decltype(range_mapper<buffered_context<Char>>{}
-                                          .map(std::declval<Element>()))>,
-              Char>;
+using range_formatter_type = formatter<remove_cvref_t<Element>, Char>;

 template <typename R>
 using maybe_const_range =
@ -415,7 +394,7 @@ struct range_formatter<
    auto buf = basic_memory_buffer<Char>();
    for (; it != end; ++it) buf.push_back(*it);
    auto specs = format_specs();
-    specs.type = presentation_type::debug;
+    specs.set_type(presentation_type::debug);
    return detail::write<Char>(
        out, basic_string_view<Char>(buf.data(), buf.size()), specs);
  }
@ -443,8 +422,7 @@ struct range_formatter<
    closing_bracket_ = close;
  }

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    auto it = ctx.begin();
    auto end = ctx.end();
    detail::maybe_set_debug_format(underlying_, true);
@ -486,7 +464,6 @@ struct range_formatter<

  template <typename R, typename FormatContext>
  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto mapper = detail::range_mapper<buffered_context<Char>>();
    auto out = ctx.out();
    auto it = detail::range_begin(range);
    auto end = detail::range_end(range);
@ -498,7 +475,7 @@ struct range_formatter<
      if (i > 0) out = detail::copy<Char>(separator_, out);
      ctx.advance_to(out);
      auto&& item = *it;  // Need an lvalue
-      out = underlying_.format(mapper.map(item), ctx);
+      out = underlying_.format(item, ctx);
      ++i;
    }
    out = detail::copy<Char>(closing_bracket_, out);
@ -543,8 +520,7 @@ struct formatter<
                                  detail::string_literal<Char, '}'>{});
  }

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return range_formatter_.parse(ctx);
  }

@ -571,8 +547,7 @@ struct formatter<
 public:
  FMT_CONSTEXPR formatter() {}

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it != end) {
@ -586,7 +561,7 @@ struct formatter<
      }
      ctx.advance_to(it);
    }
-    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
+    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
    return it;
  }

@ -596,12 +571,11 @@ struct formatter<
    basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
    if (!no_delimiters_) out = detail::copy<Char>(open, out);
    int i = 0;
-    auto mapper = detail::range_mapper<buffered_context<Char>>();
    basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
    for (auto&& value : map) {
      if (i > 0) out = detail::copy<Char>(sep, out);
      ctx.advance_to(out);
-      detail::for_each2(formatters_, mapper.map(value),
+      detail::for_each2(formatters_, value,
                        detail::format_tuple_element<FormatContext>{
                            0, ctx, detail::string_literal<Char, ':', ' '>{}});
      ++i;
@ -631,8 +605,7 @@ struct formatter<
  formatter<string_type, Char> underlying_;

 public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return underlying_.parse(ctx);
  }

@ -680,8 +653,7 @@ struct formatter<join_view<It, Sentinel, Char>, Char> {
 public:
  using nonlocking = void;

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return value_formatter_.parse(ctx);
  }

@ -748,8 +720,7 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {

 template <typename Char, typename... T>
 struct formatter<tuple_join_view<Char, T...>, Char> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
  }

@ -763,17 +734,16 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
 private:
  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;

-  template <typename ParseContext>
-  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
                              std::integral_constant<size_t, 0>)
-      -> decltype(ctx.begin()) {
+      -> const Char* {
    return ctx.begin();
  }

-  template <typename ParseContext, size_t N>
-  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+  template <size_t N>
+  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
                              std::integral_constant<size_t, N>)
-      -> decltype(ctx.begin()) {
+      -> const Char* {
    auto end = ctx.begin();
 #if FMT_TUPLE_JOIN_SPECIFIERS
    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
--- a/3rdparty/fmt/include/fmt/std.h
+++ b/3rdparty/fmt/include/fmt/std.h
@ -17,6 +17,7 @@
 #  include <complex>
 #  include <cstdlib>
 #  include <exception>
+#  include <functional>
 #  include <memory>
 #  include <thread>
 #  include <type_traits>
@ -122,14 +123,16 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
 public:
  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }

-  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end) return it;

    it = detail::parse_align(it, end, specs_);
    if (it == end) return it;

-    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
+    Char c = *it;
+    if ((c >= '0' && c <= '9') || c == '{')
+      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
    if (it != end && *it == '?') {
      debug_ = true;
      ++it;
@ -145,8 +148,8 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
        !path_type_ ? p.native()
                    : p.generic_string<std::filesystem::path::value_type>();

-    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
-                                                       ctx);
+    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
+                                ctx);
    if (!debug_) {
      auto s = detail::get_path_string<Char>(p, path_string);
      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
@ -233,7 +236,7 @@ struct formatter<std::optional<T>, Char,
  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}

 public:
-  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
    maybe_set_debug_format(underlying_, true);
    return underlying_.parse(ctx);
  }
@ -277,10 +280,10 @@ FMT_BEGIN_NAMESPACE
 FMT_EXPORT
 template <typename T, typename E, typename Char>
 struct formatter<std::expected<T, E>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value &&
+                 std::enable_if_t<(std::is_void<T>::value ||
+                                   is_formattable<T, Char>::value) &&
                                  is_formattable<E, Char>::value>> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return ctx.begin();
  }

@ -291,7 +294,8 @@ struct formatter<std::expected<T, E>, Char,

    if (value.has_value()) {
      out = detail::write<Char>(out, "expected(");
-      out = detail::write_escaped_alternative<Char>(out, *value);
+      if constexpr (!std::is_void<T>::value)
+        out = detail::write_escaped_alternative<Char>(out, *value);
    } else {
      out = detail::write<Char>(out, "unexpected(");
      out = detail::write_escaped_alternative<Char>(out, value.error());
@ -307,9 +311,7 @@ FMT_END_NAMESPACE
 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
 template <> struct formatter<std::source_location> {
-  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
-    return ctx.begin();
-  }
+  FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }

  template <typename FormatContext>
  auto format(const std::source_location& loc, FormatContext& ctx) const
@ -365,8 +367,7 @@ template <typename T, typename C> struct is_variant_formattable {

 FMT_EXPORT
 template <typename Char> struct formatter<std::monostate, Char> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return ctx.begin();
  }

@ -383,8 +384,7 @@ struct formatter<
    Variant, Char,
    std::enable_if_t<std::conjunction_v<
        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return ctx.begin();
  }

@ -413,20 +413,37 @@ FMT_END_NAMESPACE

 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
-template <typename Char> struct formatter<std::error_code, Char> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
+template <> struct formatter<std::error_code> {
+ private:
+  format_specs specs_;
+  detail::arg_ref<char> width_ref_;
+
+ public:
+  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end) return it;
+
+    it = detail::parse_align(it, end, specs_);
+    if (it == end) return it;
+
+    char c = *it;
+    if ((c >= '0' && c <= '9') || c == '{')
+      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
+    return it;
  }

  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write_bytes<Char>(out, ec.category().name(), format_specs());
-    out = detail::write<Char>(out, Char(':'));
-    out = detail::write<Char>(out, ec.value());
-    return out;
+  FMT_CONSTEXPR20 auto format(const std::error_code& ec,
+                              FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto specs = specs_;
+    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
+                                ctx);
+    memory_buffer buf;
+    buf.append(string_view(ec.category().name()));
+    buf.push_back(':');
+    detail::write<char>(appender(buf), ec.value());
+    return detail::write<char>(ctx.out(), string_view(buf.data(), buf.size()),
+                               specs);
  }
 };

@ -506,8 +523,7 @@ template <typename Char>
 struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
                 > {
 public:
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    return ctx.begin();
  }

@ -528,8 +544,7 @@ struct formatter<
  bool with_typename_ = false;

 public:
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it == end || *it == '}') return it;
@ -643,7 +658,7 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
    if (c.real() != 0) {
      *out++ = Char('(');
      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
-      specs.sign = sign::plus;
+      specs.set_sign(sign::plus);
      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
      *out++ = Char('i');
@ -657,8 +672,7 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
  }

 public:
-  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-      -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
                              detail::type_constant<T, Char>::value);
@ -668,12 +682,11 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
  auto format(const std::complex<T>& c, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto specs = specs_;
-    if (specs.width_ref.kind != detail::arg_id_kind::none ||
-        specs.precision_ref.kind != detail::arg_id_kind::none) {
-      detail::handle_dynamic_spec<detail::width_checker>(specs.width,
-                                                         specs.width_ref, ctx);
-      detail::handle_dynamic_spec<detail::precision_checker>(
-          specs.precision, specs.precision_ref, ctx);
+    if (specs.dynamic()) {
+      detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
+                                  specs.width_ref, ctx);
+      detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
+                                  specs.precision_ref, ctx);
    }

    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
@ -681,12 +694,14 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {

    auto outer_specs = format_specs();
    outer_specs.width = specs.width;
-    outer_specs.fill = specs.fill;
-    outer_specs.align = specs.align;
+    auto fill = specs.template fill<Char>();
+    if (fill)
+      outer_specs.set_fill(basic_string_view<Char>(fill, specs.fill_size()));
+    outer_specs.set_align(specs.align());

    specs.width = 0;
-    specs.fill = {};
-    specs.align = align::none;
+    specs.set_fill({});
+    specs.set_align(align::none);

    do_format(c, specs, ctx, basic_appender<Char>(buf));
    return detail::write<Char>(ctx.out(),
@ -695,5 +710,17 @@ template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
  }
 };

+FMT_EXPORT
+template <typename T, typename Char>
+struct formatter<std::reference_wrapper<T>, Char,
+                 enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>>
+    : formatter<remove_cvref_t<T>, Char> {
+  template <typename FormatContext>
+  auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx);
+  }
+};
+
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_
--- a/3rdparty/fmt/include/fmt/xchar.h
+++ b/3rdparty/fmt/include/fmt/xchar.h
@ -10,11 +10,12 @@

 #include "color.h"
 #include "format.h"
+#include "ostream.h"
 #include "ranges.h"

 #ifndef FMT_MODULE
 #  include <cwchar>
-#  if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+#  if FMT_USE_LOCALE
 #    include <locale>
 #  endif
 #endif
@ -34,7 +35,8 @@ struct format_string_char<
 };

 template <typename S>
-struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> {
+struct format_string_char<
+    S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> {
  using type = typename S::char_type;
 };

@ -43,7 +45,7 @@ using format_string_char_t = typename format_string_char<S>::type;

 inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
                      const format_specs& specs, locale_ref loc) -> bool {
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#if FMT_USE_LOCALE
  auto& numpunct =
      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
  auto separator = std::wstring();
@ -58,30 +60,64 @@ inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
 FMT_BEGIN_EXPORT

 using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_parse_context = parse_context<wchar_t>;
 using wformat_context = buffered_context<wchar_t>;
 using wformat_args = basic_format_args<wformat_context>;
 using wmemory_buffer = basic_memory_buffer<wchar_t>;

-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-// Workaround broken conversion on older gcc.
-template <typename... Args> using wformat_string = wstring_view;
-inline auto runtime(wstring_view s) -> wstring_view { return s; }
-#else
-template <typename... Args>
-using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+template <typename Char, typename... T> struct basic_fstring {
+ private:
+  basic_string_view<Char> str_;
+
+  static constexpr int num_static_named_args =
+      detail::count_static_named_args<T...>();
+
+  using checker = detail::format_string_checker<
+      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
+      num_static_named_args != detail::count_named_args<T...>()>;
+
+  using arg_pack = detail::arg_pack<T...>;
+
+ public:
+  using t = basic_fstring;
+
+  template <typename S,
+            FMT_ENABLE_IF(
+                std::is_convertible<const S&, basic_string_view<Char>>::value)>
+  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {
+    if (FMT_USE_CONSTEVAL)
+      detail::parse_format_string<Char>(s, checker(s, arg_pack()));
+  }
+  template <typename S,
+            FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
+                              std::is_same<typename S::char_type, Char>::value)>
+  FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {
+    FMT_CONSTEXPR auto sv = basic_string_view<Char>(S());
+    FMT_CONSTEXPR int ignore =
+        (parse_format_string(sv, checker(sv, arg_pack())), 0);
+    detail::ignore_unused(ignore);
+  }
+  basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {}
+
+  operator basic_string_view<Char>() const { return str_; }
+  auto get() const -> basic_string_view<Char> { return str_; }
+};
+
+template <typename Char, typename... T>
+using basic_format_string = basic_fstring<Char, T...>;
+
+template <typename... T>
+using wformat_string = typename basic_format_string<wchar_t, T...>::t;
 inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
  return {{s}};
 }
-#endif

 template <> struct is_char<wchar_t> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};

 #ifdef __cpp_char8_t
-template <>
-struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled()> {};
+template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
 #endif

 template <typename... T>
@ -90,14 +126,13 @@ constexpr auto make_wformat_args(T&... args)
  return fmt::make_format_args<wformat_context>(args...);
 }

+#if !FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
-constexpr auto operator""_a(const wchar_t* s, size_t)
-    -> detail::udl_arg<wchar_t> {
+inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
  return {s};
 }
-#endif
 }  // namespace literals
+#endif

 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@ -107,7 +142,7 @@ auto join(It begin, Sentinel end, wstring_view sep)

 template <typename Range>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
                 wchar_t> {
  return join(std::begin(range), std::end(range), sep);
 }
@ -125,12 +160,12 @@ auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep)
 }

 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> format_str,
+auto vformat(basic_string_view<Char> fmt,
             typename detail::vformat_args<Char>::type args)
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, format_str, args);
-  return to_string(buf);
+  detail::vformat_to(buf, fmt, args);
+  return {buf.data(), buf.size()};
 }

 template <typename... T>
@ -151,40 +186,39 @@ template <typename S, typename... T,
          typename Char = detail::format_string_char_t<S>,
          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                        !std::is_same<Char, wchar_t>::value)>
-auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(format_str),
+auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(fmt),
                 fmt::make_format_args<buffered_context<Char>>(args...));
 }

-template <typename Locale, typename S,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto vformat(const Locale& loc, const S& format_str,
+template <typename S, typename Char = detail::format_string_char_t<S>,
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto vformat(detail::locale_ref loc, const S& fmt,
                    typename detail::vformat_args<Char>::type args)
    -> std::basic_string<Char> {
-  return detail::vformat(loc, detail::to_string_view(format_str), args);
+  auto buf = basic_memory_buffer<Char>();
+  detail::vformat_to(buf, detail::to_string_view(fmt), args,
+                     detail::locale_ref(loc));
+  return {buf.data(), buf.size()};
 }

-template <typename Locale, typename S, typename... T,
+template <typename S, typename... T,
          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format(const Locale& loc, const S& format_str, T&&... args)
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto format(detail::locale_ref loc, const S& fmt, T&&... args)
    -> std::basic_string<Char> {
-  return detail::vformat(
-      loc, detail::to_string_view(format_str),
-      fmt::make_format_args<buffered_context<Char>>(args...));
+  return vformat(loc, detail::to_string_view(fmt),
+                 fmt::make_format_args<buffered_context<Char>>(args...));
 }

 template <typename OutputIt, typename S,
          typename Char = detail::format_string_char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-auto vformat_to(OutputIt out, const S& format_str,
+auto vformat_to(OutputIt out, const S& fmt,
                typename detail::vformat_args<Char>::type args) -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, detail::to_string_view(format_str), args);
+  detail::vformat_to(buf, detail::to_string_view(fmt), args);
  return detail::get_iterator(buf, out);
 }

@ -198,42 +232,38 @@ inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
                    fmt::make_format_args<buffered_context<Char>>(args...));
 }

-template <typename Locale, typename S, typename OutputIt, typename... Args,
+template <typename S, typename OutputIt, typename... Args,
          typename Char = detail::format_string_char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_locale<Locale>::value&&
-                                detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(OutputIt out, const Locale& loc, const S& format_str,
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(OutputIt out, detail::locale_ref loc, const S& fmt,
                       typename detail::vformat_args<Char>::type args)
    -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, detail::to_string_view(format_str), args,
-             detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc));
  return detail::get_iterator(buf, out);
 }

-template <typename OutputIt, typename Locale, typename S, typename... T,
+template <typename OutputIt, typename S, typename... T,
          typename Char = detail::format_string_char_t<S>,
          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
-                        detail::is_locale<Locale>::value &&
                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+inline auto format_to(OutputIt out, detail::locale_ref loc, const S& fmt,
                      T&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(format_str),
+  return vformat_to(out, loc, detail::to_string_view(fmt),
                    fmt::make_format_args<buffered_context<Char>>(args...));
 }

 template <typename OutputIt, typename Char, typename... Args,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(OutputIt out, size_t n,
-                         basic_string_view<Char> format_str,
+inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt,
                         typename detail::vformat_args<Char>::type args)
    -> format_to_n_result<OutputIt> {
  using traits = detail::fixed_buffer_traits;
  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, format_str, args);
+  detail::vformat_to(buf, fmt, args);
  return {buf.out(), buf.count()};
 }

@ -291,7 +321,7 @@ inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
    -> std::wstring {
  auto buf = wmemory_buffer();
  detail::vformat_to(buf, ts, fmt, args);
-  return fmt::to_string(buf);
+  return {buf.data(), buf.size()};
 }

 template <typename... T>
@ -312,6 +342,22 @@ FMT_DEPRECATED void print(const text_style& ts, wformat_string<T...> fmt,
  return print(stdout, ts, fmt, args...);
 }

+inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
+  auto buffer = basic_memory_buffer<wchar_t>();
+  detail::vformat_to(buffer, fmt, args);
+  detail::write_buffer(os, buffer);
+}
+
+template <typename... T>
+void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
+}
+
+template <typename... T>
+void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
+  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
 /// Converts `value` to `std::wstring` using the default format for type `T`.
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
  return format(FMT_STRING(L"{}"), value);
--- a/3rdparty/fmt/src/fmt.cc
+++ b/3rdparty/fmt/src/fmt.cc
@ -1,5 +1,11 @@
 module;

+#ifdef _MSVC_LANG
+#  define FMT_CPLUSPLUS _MSVC_LANG
+#else
+#  define FMT_CPLUSPLUS __cplusplus
+#endif
+
 // Put all implementation-provided headers into the global module fragment
 // to prevent attachment to this module.
 #ifndef FMT_IMPORT_STD
@ -15,7 +21,9 @@ module;
 #  include <cstring>
 #  include <ctime>
 #  include <exception>
-#  include <expected>
+#  if FMT_CPLUSPLUS > 202002L
+#    include <expected>
+#  endif
 #  include <filesystem>
 #  include <fstream>
 #  include <functional>
@ -127,9 +135,17 @@ extern "C++" {
 module :private;
 #endif

+#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
+extern "C++" {
+#endif
+
 #if FMT_HAS_INCLUDE("format.cc")
 #  include "format.cc"
 #endif
 #if FMT_OS && FMT_HAS_INCLUDE("os.cc")
 #  include "os.cc"
 #endif
+
+#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
+}
+#endif
--- a/3rdparty/fmt/src/format.cc
+++ b/3rdparty/fmt/src/format.cc
@ -15,7 +15,8 @@ template FMT_API auto dragonbox::to_decimal(float x) noexcept
 template FMT_API auto dragonbox::to_decimal(double x) noexcept
    -> dragonbox::decimal_fp<double>;

-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#if FMT_USE_LOCALE
+// DEPRECATED! locale_ref in the detail namespace
 template FMT_API locale_ref::locale_ref(const std::locale& loc);
 template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
 #endif
@ -26,8 +27,10 @@ template FMT_API auto thousands_sep_impl(locale_ref)
    -> thousands_sep_result<char>;
 template FMT_API auto decimal_point_impl(locale_ref) -> char;

+// DEPRECATED!
 template FMT_API void buffer<char>::append(const char*, const char*);

+// DEPRECATED!
 template FMT_API void vformat_to(buffer<char>&, string_view,
                                 typename vformat_args<>::type, locale_ref);

--- a/3rdparty/fmt/src/os.cc
+++ b/3rdparty/fmt/src/os.cc
@ -160,7 +160,7 @@ void detail::format_windows_error(detail::buffer<char>& out, int error_code,
 }

 void report_windows_error(int error_code, const char* message) noexcept {
-  report_error(detail::format_windows_error, error_code, message);
+  do_report_error(detail::format_windows_error, error_code, message);
 }
 #endif  // _WIN32

@ -374,30 +374,25 @@ long getpagesize() {
 }
 #  endif

-namespace detail {
-
-void file_buffer::grow(buffer<char>& buf, size_t) {
-  if (buf.size() == buf.capacity()) static_cast<file_buffer&>(buf).flush();
+void ostream::grow(buffer<char>& buf, size_t) {
+  if (buf.size() == buf.capacity()) static_cast<ostream&>(buf).flush();
 }

-file_buffer::file_buffer(cstring_view path, const ostream_params& params)
+ostream::ostream(cstring_view path, const detail::ostream_params& params)
    : buffer<char>(grow), file_(path, params.oflag) {
  set(new char[params.buffer_size], params.buffer_size);
 }

-file_buffer::file_buffer(file_buffer&& other) noexcept
+ostream::ostream(ostream&& other) noexcept
    : buffer<char>(grow, other.data(), other.size(), other.capacity()),
      file_(std::move(other.file_)) {
  other.clear();
  other.set(nullptr, 0);
 }

-file_buffer::~file_buffer() {
+ostream::~ostream() {
  flush();
  delete[] data();
 }
-}  // namespace detail
-
-ostream::~ostream() = default;
 #endif  // FMT_USE_FCNTL
 FMT_END_NAMESPACE
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,22 +1,85 @@
-## axmol-2.2.0 ??
+## axmol-2.2.0 Oct.20 2024
+
+### Significant changes relative to 2.1.5:
+
+- Enable vsync by default by @halx99 in https://github.com/axmolengine/axmol/pull/2118
+- Improve android media player, also fix #2101 by @halx99 in https://github.com/axmolengine/axmol/pull/2109
+- Add build on ubuntu 24.04 support by @halx99 in https://github.com/axmolengine/axmol/pull/2152
+- No longer add sprite as child of RenderTexture by @halx99 in https://github.com/axmolengine/axmol/pull/2149
+- API change too: remove all DrawNode setLineWidth() stuff by @aismann in https://github.com/axmolengine/axmol/pull/2172
+
+### Bug fixes
+
+- Fix invalidated iterator access in `Scheduler::unscheduleAllWithMinPriority()` by @smilediver in https://github.com/axmolengine/axmol/pull/2194
+- Fix label in PauseTest. by @Tosik86 in https://github.com/axmolengine/axmol/pull/2157
+- Fix #2147 full screen incorrect on macOS by @halx99 in https://github.com/axmolengine/axmol/pull/2150
+- Fix RenderTargetGL FBO not recreate when recv EVENT_RENDERER_RECREATED by @halx99 in https://github.com/axmolengine/axmol/pull/2148
+- Fix EventMouse coords by @halx99 in https://github.com/axmolengine/axmol/pull/2141
+- Fix for incorrect bits per pixel set on texture reload by @rh101 in https://github.com/axmolengine/axmol/pull/2138
+- Fix move constructor comment in Data class by @Tosik86 in https://github.com/axmolengine/axmol/pull/2132
+- Fix Node `setPosition()` and `setPositionNormalized()` not switching normalized mode if positions match by @smilediver in https://github.com/axmolengine/axmol/pull/2102
+- Fix issue with widget positioning when using normalized coordinates by @rh101 in https://github.com/axmolengine/axmol/pull/2110
+- Fix RenderTexture data needs to be saved to the cache before the GLSurfaceView context is lost by @rh101 in https://github.com/axmolengine/axmol/pull/2146
+- Fix incorrect static value usage in JNI array methods by @rh101 in https://github.com/axmolengine/axmol/pull/2178
+- Fix #2199 by @halx99 in https://github.com/axmolengine/axmol/pull/2200
+- Fix LuaJit Compilations by @IamSanjid in https://github.com/axmolengine/axmol/pull/2159
+- Fix #2163 by @halx99 in https://github.com/axmolengine/axmol/pull/2166
+- Fix #2169 by @halx99 in https://github.com/axmolengine/axmol/pull/2170
+- fix Crash Sprite when _texture null by @NgVThangBz in https://github.com/axmolengine/axmol/pull/2164
+- Fix dangling ref in `SpriteFrameCache::removeSpriteFramesFromTexture()` by @smilediver in https://github.com/axmolengine/axmol/pull/2106
+- Fix android fps issue when certain animation intervals are set by @rh101 in https://github.com/axmolengine/axmol/pull/2162
+- Fix DownloaderCURL too many open files and other fixes by @smilediver in https://github.com/axmolengine/axmol/pull/2182
+ 
+### Improvements
+
+- [ImGui] Allow setting of custom font config to enable merging of multiple fonts and other features by @rh101 in https://github.com/axmolengine/axmol/pull/2085
+- Update DevSetup.md with iOS simulator build commands by @rh101 in https://github.com/axmolengine/axmol/pull/2087
+- Remove couple bad warnings by @smilediver in https://github.com/axmolengine/axmol/pull/2088
+- Trim trailing whitespace for files in `core` folder by @smilediver in https://github.com/axmolengine/axmol/pull/2089
+- Remove the NS_AX_BEGIN and NS_AX_END macros. by @j-jorge in https://github.com/axmolengine/axmol/pull/2100
+- Remove the USING_NS_AX and NS_AX macros. by @j-jorge in https://github.com/axmolengine/axmol/pull/2103
+- Remove usage of the NS_AX macro. by @j-jorge in https://github.com/axmolengine/axmol/pull/2107
+- Sprite: show stretch warning only if stretching is enabled by @smilediver in https://github.com/axmolengine/axmol/pull/2113
+- Delay load mf.dll, mfplat.dll by @halx99 in https://github.com/axmolengine/axmol/pull/2116
+- Remove unreferenced sprite from test scene by @rh101 in https://github.com/axmolengine/axmol/pull/2119
+- Set RenderTexture content size on creation by @rh101 in https://github.com/axmolengine/axmol/pull/2120
+- Update sweep.h  (fix invalid UTF-8) by @aismann in https://github.com/axmolengine/axmol/pull/2121
+- Math optimizations by @smilediver in https://github.com/axmolengine/axmol/pull/2115
+- DrawNode V2  by @aismann in https://github.com/axmolengine/axmol/pull/2124
+- USe gradle-8.8-bin.zip everywhere by @crazyhappygame in https://github.com/axmolengine/axmol/pull/2134
+- Refine contributing.md guide by @Tosik86 in https://github.com/axmolengine/axmol/pull/2135
+- Allow turn on/off deprecated features by @halx99 in https://github.com/axmolengine/axmol/pull/2136
+- Math: remove and replace GP_ASSERT with AX_ASSERT by @smilediver in https://github.com/axmolengine/axmol/pull/2143
+- Enable cache render data for webgl by default by @halx99 in https://github.com/axmolengine/axmol/pull/2151
+- Fix some compiling deprecated issues by @halx99 in https://github.com/axmolengine/axmol/pull/2154
+- Update DrawNode.cpp (fix #2140) by @aismann in https://github.com/axmolengine/axmol/pull/2158
+- Add (missing) parameter 'drawLineToCenter' to 'drawSolidCircle(...)' by @aismann in https://github.com/axmolengine/axmol/pull/2160
+- Optimize DrawNode by @smilediver in https://github.com/axmolengine/axmol/pull/2165
+- remove DrawPrimitivesTests (Cocos2Dx) (redundant mit DrawNodeTest) by @aismann in https://github.com/axmolengine/axmol/pull/2179
+- move ZwoptexTest to SpriteTest (better add it to the SpriteTest section as removing) by @aismann in https://github.com/axmolengine/axmol/pull/2180
+- Update README.md (thirdparty) by @aismann in https://github.com/axmolengine/axmol/pull/2183
+- `AxmolActivity` refactoring and fixes by @smilediver in https://github.com/axmolengine/axmol/pull/2185
+- Update controller.cpp Add small hint that the DrawNode tests be "not finished": "Node: Draw (WIP)" by @aismann in https://github.com/axmolengine/axmol/pull/2189
+- DrawNode calls: replacing Color4F with Color4B (without the 'test' folder!) by @aismann in https://github.com/axmolengine/axmol/pull/2192

 ### sdks updates

- emsdk: 3.1.63 ==> 3.1.67
+- emsdk: 3.1.63 ==> 3.1.69

 ### 3rdparty updates

- glad: 2.0.6 ==> 2.0.7
+- glad: 2.0.6 ==> 2.0.8
 - curl: 8.9.1 ==> 8.10.1
 - simdjson: 3.10.0 ==> 3.10.1
 - libpng: 1.6.43 ==> 1.6.44
- c-ares: 1.33.0 ==> 1.33.1
+- c-ares: 1.33.0 ==> 1.34.1
 - openssl: 3.3.1 ==> 3.0.15
 - yasio: 4.2.4 ==> 4.3.1
 - jpeg-turbo: 3.0.3 ==> 3.0.4
- luajit: 2.1-04dca79 ==> 2.1-87ae18a
+- luajit: 2.1-04dca79 ==> 2.1-97813fb
 - simdjson: 3.10.0 ==> 3.10.1
 - rapidjson: 1.1.0-b4a6da3 ==> 1.1.0-815e6e7
+- freetype: 2.13.2 ==> 2.13.3

 ## axmol-2.1.5 Aug.11 2024