fmt: Bump to version v10.1.1

2023-11-28 13:52:27 +10:00 · 2023-11-28 13:52:27 +10:00 · 7fe3bfece0
parent 333c9fdf6f
commit 7fe3bfece0
22 changed files with 4603 additions and 3413 deletions
--- a/dep/CMakeLists.txt
+++ b/dep/CMakeLists.txt
@ -1,3 +1,4 @@
 set(FMT_INSTALL OFF CACHE BOOL "")
 add_subdirectory(fmt EXCLUDE_FROM_ALL)
 disable_compiler_warnings_for_target(fmt)
 add_subdirectory(stb EXCLUDE_FROM_ALL)
--- a/dep/fmt/CMakeLists.txt
+++ b/dep/fmt/CMakeLists.txt
@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1...3.18)
+cmake_minimum_required(VERSION 3.8...3.26)
 # Fallback for using newer policies on CMake <3.12.
 if(${CMAKE_VERSION} VERSION_LESS 3.12)
@ -24,15 +24,86 @@ function(join result_var)
  set(${result_var} "${result}" PARENT_SCOPE)
 endfunction()
 # DEPRECATED! Should be merged into add_module_library.
 function(enable_module target)
  if (MSVC)
    set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
    target_compile_options(${target}
      PRIVATE /interface /ifcOutput ${BMI}
      INTERFACE /reference fmt=${BMI})
    set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
    set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
  endif ()
-  set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
+endfunction()
-  set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
+
 # Adds a library compiled with C++20 module support.
 # `enabled` is a CMake variables that specifies if modules are enabled.
 # If modules are disabled `add_module_library` falls back to creating a
 # non-modular library.
 #
 # Usage:
 #   add_module_library(<name> [sources...] FALLBACK [sources...] [IF enabled])
 function(add_module_library name)
  cmake_parse_arguments(AML "" "IF" "FALLBACK" ${ARGN})
  set(sources ${AML_UNPARSED_ARGUMENTS})
  add_library(${name})
  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
  if (NOT ${${AML_IF}})
    # Create a non-modular library.
    target_sources(${name} PRIVATE ${AML_FALLBACK})
    return()
  endif ()
  # Modules require C++20.
  target_compile_features(${name} PUBLIC cxx_std_20)
  if (CMAKE_COMPILER_IS_GNUCXX)
    target_compile_options(${name} PUBLIC -fmodules-ts)
  endif ()
  # `std` is affected by CMake options and may be higher than C++20.
  get_target_property(std ${name} CXX_STANDARD)
  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    set(pcms)
    foreach (src ${sources})
      get_filename_component(pcm ${src} NAME_WE)
      set(pcm ${pcm}.pcm)
      # Propagate -fmodule-file=*.pcm to targets that link with this library.
      target_compile_options(
        ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
      # Use an absolute path to prevent target_link_libraries prepending -l
      # to it.
      set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
      add_custom_command(
        OUTPUT ${pcm}
        COMMAND ${CMAKE_CXX_COMPILER}
                -std=c++${std} -x c++-module --precompile -c
                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
        # Required by the -I generator expression above.
        COMMAND_EXPAND_LISTS
        DEPENDS ${src})
    endforeach ()
    # Add .pcm files as sources to make sure they are built before the library.
    set(sources)
    foreach (pcm ${pcms})
      get_filename_component(pcm_we ${pcm} NAME_WE)
      set(obj ${pcm_we}.o)
      # Use an absolute path to prevent target_link_libraries prepending -l.
      set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
      add_custom_command(
        OUTPUT ${obj}
        COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
                -c -o ${obj} ${pcm}
        DEPENDS ${pcm})
    endforeach ()
  endif ()
  target_sources(${name} PRIVATE ${sources})
 endfunction()
 include(CMakeParseArguments)
@ -75,7 +146,7 @@ option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
 # Options that control generation of various targets.
 option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
-option(FMT_INSTALL "Generate the install target." ${FMT_MASTER_PROJECT})
+option(FMT_INSTALL "Generate the install target." ON)
 option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
 option(FMT_FUZZ "Generate the fuzz target." OFF)
 option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
@ -83,16 +154,6 @@ option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
 option(FMT_MODULE "Build a module instead of a traditional library." OFF)
 option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
 set(FMT_CAN_MODULE OFF)
 if (CMAKE_CXX_STANDARD GREATER 17 AND
    # msvc 16.10-pre4
    MSVC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.29.30035)
  set(FMT_CAN_MODULE OFF)
 endif ()
 if (NOT FMT_CAN_MODULE)
  set(FMT_MODULE OFF)
  message(STATUS "Module support is disabled.")
 endif ()
 if (FMT_TEST AND FMT_MODULE)
  # The tests require {fmt} to be compiled as traditional library
  message(STATUS "Testing is incompatible with build mode 'module'.")
@ -101,6 +162,10 @@ set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
 if (FMT_SYSTEM_HEADERS)
  set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
 endif ()
 if(CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
  set(FMT_TEST OFF)
  message(STATUS "MSDOS is incompatible with gtest")
 endif()
 # Get version from core.h
 file(READ include/fmt/core.h core_h)
@ -118,23 +183,15 @@ message(STATUS "Version: ${FMT_VERSION}")
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
-  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
 endif ()
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
-include(cxx14)
+include(CheckCXXCompilerFlag)
 include(JoinPaths)
 list(FIND CMAKE_CXX_COMPILE_FEATURES "cxx_variadic_templates" index)
 if (${index} GREATER -1)
  # Use cxx_variadic_templates instead of more appropriate cxx_std_11 for
  # compatibility with older CMake versions.
  set(FMT_REQUIRED_FEATURES cxx_variadic_templates)
 endif ()
 message(STATUS "Required features: ${FMT_REQUIRED_FEATURES}")
 if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
  set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
              "Preset for the export of private symbols")
@ -220,16 +277,18 @@ endfunction()
 add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
                        format-inl.h os.h ostream.h printf.h ranges.h std.h
                        xchar.h)
-if (FMT_MODULE)
+set(FMT_SOURCES src/format.cc)
-  set(FMT_SOURCES src/fmt.cc)
+if (FMT_OS)
-elseif (FMT_OS)
+  set(FMT_SOURCES ${FMT_SOURCES} src/os.cc)
  set(FMT_SOURCES src/format.cc src/os.cc)
 else()
  set(FMT_SOURCES src/format.cc)
 endif ()
-add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS} README.rst ChangeLog.rst)
+add_module_library(fmt src/fmt.cc FALLBACK
                   ${FMT_SOURCES} ${FMT_HEADERS} README.rst ChangeLog.rst
                   IF FMT_MODULE)
 add_library(fmt::fmt ALIAS fmt)
 if (FMT_MODULE)
  enable_module(fmt)
 endif ()
 if (FMT_WERROR)
  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
@ -237,11 +296,12 @@ endif ()
 if (FMT_PEDANTIC)
  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
 endif ()
 if (FMT_MODULE)
  enable_module(fmt)
 endif ()
-target_compile_features(fmt INTERFACE ${FMT_REQUIRED_FEATURES})
+if (cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
  target_compile_features(fmt PUBLIC cxx_std_11)
 else ()
  message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
 endif ()
 target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
@ -262,13 +322,7 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 endif ()
 if (BUILD_SHARED_LIBS)
-  if (UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS" AND
+  target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
      NOT EMSCRIPTEN)
    # Fix rpmlint warning:
    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
    target_link_libraries(fmt -Wl,--as-needed)
  endif ()
  target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
 endif ()
 if (FMT_SAFE_DURATION_CAST)
  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
@ -278,7 +332,7 @@ add_library(fmt-header-only INTERFACE)
 add_library(fmt::fmt-header-only ALIAS fmt-header-only)
 target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
-target_compile_features(fmt-header-only INTERFACE ${FMT_REQUIRED_FEATURES})
+target_compile_features(fmt-header-only INTERFACE cxx_std_11)
 target_include_directories(fmt-header-only ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
@ -300,7 +354,7 @@ if (FMT_INSTALL)
              "Installation directory for libraries, a relative path that "
              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
-  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE PATH
+  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
              "Installation directory for pkgconfig (.pc) files, a relative "
              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
              "absolute path.")
@ -330,7 +384,6 @@ if (FMT_INSTALL)
          LIBRARY DESTINATION ${FMT_LIB_DIR}
          ARCHIVE DESTINATION ${FMT_LIB_DIR}
          PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
          FRAMEWORK DESTINATION "."
          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  # Use a namespace because CMake provides better diagnostics for namespaced
@ -345,8 +398,6 @@ if (FMT_INSTALL)
  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
          NAMESPACE fmt::)
  install(FILES $<TARGET_PDB_FILE:${INSTALL_TARGETS}>
          DESTINATION ${FMT_LIB_DIR} OPTIONAL)
  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
 endif ()
--- a/dep/fmt/ChangeLog.rst
+++ b/dep/fmt/ChangeLog.rst
@ -1,3 +1,796 @@
 10.1.1 - 2023-08-28
 -------------------
 * Added formatters for ``std::atomic`` and ``atomic_flag``
  (`#3574 <https://github.com/fmtlib/fmt/pull/3574>`_,
  `#3594 <https://github.com/fmtlib/fmt/pull/3594>`_).
  Thanks `@wangzw (Zhanwei Wang) <https://github.com/wangzw>`_ and
  `@AlexGuteniev (Alex Guteniev) <https://github.com/AlexGuteniev>`_.
 * Fixed an error about partial specialization of ``formatter<string>``
  after instantiation when compiled with gcc and C++20
  (`#3584 <https://github.com/fmtlib/fmt/issues/3584>`_).
 * Fixed compilation as a C++20 module with gcc and clang
  (`#3587 <https://github.com/fmtlib/fmt/issues/3587>`_,
  `#3597 <https://github.com/fmtlib/fmt/pull/3597>`_,
  `#3605 <https://github.com/fmtlib/fmt/pull/3605>`_). Thanks
  `@MathewBensonCode (Mathew Benson) <https://github.com/MathewBensonCode>`_.
 * Made ``fmt::to_string`` work with types that have ``format_as`` overloads
  (`#3575 <https://github.com/fmtlib/fmt/pull/3575>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Made ``formatted_size`` work with integral format specifiers at compile time
  (`#3591 <https://github.com/fmtlib/fmt/pull/3591>`_).
  Thanks `@elbeno (Ben Deane) <https://github.com/elbeno>`_.
 * Fixed a warning about the ``no_unique_address`` attribute on clang-cl
  (`#3599 <https://github.com/fmtlib/fmt/pull/3599>`_).
  Thanks `@lukester1975 <https://github.com/lukester1975>`_.
 * Improved compatibility with the legacy GBK encoding
  (`#3598 <https://github.com/fmtlib/fmt/issues/3598>`_,
  `#3599 <https://github.com/fmtlib/fmt/pull/3599>`_).
  Thanks `@YuHuanTin <https://github.com/YuHuanTin>`_.
 * Added OpenSSF Scorecard analysis
  (`#3530 <https://github.com/fmtlib/fmt/issues/3530>`_,
  `#3571 <https://github.com/fmtlib/fmt/pull/3571>`_).
  Thanks `@joycebrum (Joyce) <https://github.com/joycebrum>`_.
 * Updated CI dependencies
  (`#3591 <https://github.com/fmtlib/fmt/pull/3591>`_,
  `#3592 <https://github.com/fmtlib/fmt/pull/3592>`_,
  `#3593 <https://github.com/fmtlib/fmt/pull/3593>`_,
  `#3602 <https://github.com/fmtlib/fmt/pull/3602>`_).
 10.1.0 - 2023-08-12
 -------------------
 * Optimized format string compilation resulting in up to 40% speed up in
  compiled ``format_to`` and ~4x speed up in compiled ``format_to_n`` on a
  concatenation benchmark (`#3133 <https://github.com/fmtlib/fmt/issues/3133>`_,
  `#3484 <https://github.com/fmtlib/fmt/issues/3484>`_).
  {fmt} 10.0::
    ---------------------------------------------------------
    Benchmark               Time             CPU   Iterations
    ---------------------------------------------------------
    BM_format_to         78.9 ns         78.9 ns      8881746
    BM_format_to_n        568 ns          568 ns      1232089
  {fmt} 10.1::
    ---------------------------------------------------------
    Benchmark               Time             CPU   Iterations
    ---------------------------------------------------------
    BM_format_to         54.9 ns         54.9 ns     12727944
    BM_format_to_n        133 ns          133 ns      5257795
 * Optimized storage of an empty allocator in ``basic_memory_buffer``
  (`#3485 <https://github.com/fmtlib/fmt/pull/3485>`_).
  Thanks `@Minty-Meeo <https://github.com/Minty-Meeo>`_.
 * Added formatters for proxy references to elements of ``std::vector<bool>`` and
  ``std::bitset<N>`` (`#3567 <https://github.com/fmtlib/fmt/issues/3567>`_,
  `#3570 <https://github.com/fmtlib/fmt/pull/3570>`_).
  For example (`godbolt <https://godbolt.org/z/zYb79Pvn8>`__):
  .. code:: c++
     #include <vector>
     #include <fmt/std.h>
     int main() {
       auto v = std::vector<bool>{true};
       fmt::print("{}", v[0]);
     }
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_ and
  `@felix642 (Félix-Antoine Constantin) <https://github.com/felix642>`_.
 * Fixed an ambiguous formatter specialization for containers that look like
  container adaptors such as ``boost::flat_set``
  (`#3556 <https://github.com/fmtlib/fmt/issues/3556>`_,
  `#3561 <https://github.com/fmtlib/fmt/pull/3561>`_).
  Thanks `@5chmidti <https://github.com/5chmidti>`_.
 * Fixed compilation when formatting durations not convertible from
  ``std::chrono::seconds`` (`#3430 <https://github.com/fmtlib/fmt/pull/3430>`_).
  Thanks `@patlkli (Patrick Geltinger) <https://github.com/patlkli>`_.
 * Made the ``formatter`` specialization for ``char*`` const-correct
  (`#3432 <https://github.com/fmtlib/fmt/pull/3432>`_).
  Thanks `@timsong-cpp <https://github.com/timsong-cpp>`_.
 * Made ``{}`` and ``{:}`` handled consistently during compile-time checks
  (`#3526 <https://github.com/fmtlib/fmt/issues/3526>`_).
 * Disallowed passing temporaries to ``make_format_args`` to improve API safety
  by preventing dangling references.
 * Improved the compile-time error for unformattable types
  (`#3478 <https://github.com/fmtlib/fmt/pull/3478>`_).
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.
 * Improved the floating-point formatter
  (`#3448 <https://github.com/fmtlib/fmt/pull/3448>`_,
  `#3450 <https://github.com/fmtlib/fmt/pull/3450>`_).
  Thanks `@florimond-collette (Florimond Collette)
  <https://github.com/florimond-collette>`_.
 * Fixed handling of precision for ``long double`` larger than 64 bits.
  (`#3539 <https://github.com/fmtlib/fmt/issues/3539>`_,
  `#3564 <https://github.com/fmtlib/fmt/issues/3564>`_).
 * Made floating-point and chrono tests less platform-dependent
  (`#3337 <https://github.com/fmtlib/fmt/issues/3337>`_,
  `#3433 <https://github.com/fmtlib/fmt/issues/3433>`_,
  `#3434 <https://github.com/fmtlib/fmt/pull/3434>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Removed the remnants of the Grisu floating-point formatter that has been
  replaced by Dragonbox in earlier versions.
 * Added ``throw_format_error`` to the public API
  (`#3551 <https://github.com/fmtlib/fmt/pull/3551>`_).
  Thanks `@mjerabek (Martin Jeřábek) <https://github.com/mjerabek>`_.
 * Made ``FMT_THROW`` assert even if assertions are disabled when compiling with
  exceptions disabled (`#3418 <https://github.com/fmtlib/fmt/issues/3418>`_,
  `#3439 <https://github.com/fmtlib/fmt/pull/3439>`_).
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.
 * Made ``format_as`` and ``std::filesystem::path`` formatter work with exotic
  code unit types.
  (`#3457 <https://github.com/fmtlib/fmt/pull/3457>`_,
  `#3476 <https://github.com/fmtlib/fmt/pull/3476>`_).
  Thanks `@gix (Nico Rieck) <https://github.com/gix>`_,
  `@hmbj (Hans-Martin B. Jensen) <https://github.com/hmbj>`_.
 * Added support for the ``?`` format specifier to ``std::filesystem::path`` and
  made the default unescaped for consistency with strings.
 * Deprecated the wide stream overload of ``printf``.
 * Removed unused ``basic_printf_parse_context``.
 * Improved RTTI detection used when formatting exceptions
  (`#3468 <https://github.com/fmtlib/fmt/pull/3468>`_).
  Thanks `@danakj (Dana Jansens) <https://github.com/danakj>`_.
 * Improved compatibility with VxWorks7
  (`#3467 <https://github.com/fmtlib/fmt/pull/3467>`_).
  Thanks `@wenshan1 (Bin Lan) <https://github.com/wenshan1>`_.
 * Improved documentation
  (`#3174 <https://github.com/fmtlib/fmt/issues/3174>`_,
  `#3423 <https://github.com/fmtlib/fmt/issues/3423>`_,
  `#3454 <https://github.com/fmtlib/fmt/pull/3454>`_,
  `#3458 <https://github.com/fmtlib/fmt/issues/3458>`_,
  `#3461 <https://github.com/fmtlib/fmt/pull/3461>`_,
  `#3487 <https://github.com/fmtlib/fmt/issues/3487>`_,
  `#3515 <https://github.com/fmtlib/fmt/pull/3515>`_).
  Thanks `@zencatalyst (Kasra Hashemi) <https://github.com/zencatalyst>`_,
  `@rlalik <https://github.com/rlalik>`_,
  `@mikecrowe (Mike Crowe) <https://github.com/mikecrowe>`_.
 * Improved build and CI configurations
  (`#3449 <https://github.com/fmtlib/fmt/issues/3449>`_,
  `#3451 <https://github.com/fmtlib/fmt/pull/3451>`_,
  `#3452 <https://github.com/fmtlib/fmt/pull/3452>`_,
  `#3453 <https://github.com/fmtlib/fmt/pull/3453>`_,
  `#3459 <https://github.com/fmtlib/fmt/pull/3459>`_,
  `#3481 <https://github.com/fmtlib/fmt/issues/3481>`_,
  `#3486 <https://github.com/fmtlib/fmt/pull/3486>`_,
  `#3489 <https://github.com/fmtlib/fmt/issues/3489>`_,
  `#3496 <https://github.com/fmtlib/fmt/pull/3496>`_,
  `#3517 <https://github.com/fmtlib/fmt/issues/3517>`_,
  `#3523 <https://github.com/fmtlib/fmt/pull/3523>`_,
  `#3563 <https://github.com/fmtlib/fmt/pull/3563>`_).
  Thanks `@joycebrum (Joyce) <https://github.com/joycebrum>`_,
  `@glebm (Gleb Mazovetskiy) <https://github.com/glebm>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@petrmanek (Petr Mánek) <https://github.com/petrmanek>`_,
  `@setoye (Alta) <https://github.com/setoye>`_,
  `@abouvier (Alexandre Bouvier) <https://github.com/abouvier>`_.
 * Fixed various warnings and compilation issues
  (`#3408 <https://github.com/fmtlib/fmt/issues/3408>`_,
  `#3424 <https://github.com/fmtlib/fmt/issues/3424>`_,
  `#3444 <https://github.com/fmtlib/fmt/issues/3444>`_,
  `#3446 <https://github.com/fmtlib/fmt/pull/3446>`_,
  `#3475 <https://github.com/fmtlib/fmt/pull/3475>`_,
  `#3482 <https://github.com/fmtlib/fmt/pull/3482>`_,
  `#3492 <https://github.com/fmtlib/fmt/issues/3492>`_,
  `#3493 <https://github.com/fmtlib/fmt/pull/3493>`_,
  `#3508 <https://github.com/fmtlib/fmt/pull/3508>`_,
  `#3509 <https://github.com/fmtlib/fmt/issues/3509>`_,
  `#3533 <https://github.com/fmtlib/fmt/issues/3533>`_,
  `#3542 <https://github.com/fmtlib/fmt/pull/3542>`_,
  `#3543 <https://github.com/fmtlib/fmt/issues/3543>`_,
  `#3540 <https://github.com/fmtlib/fmt/issues/3540>`_,
  `#3544 <https://github.com/fmtlib/fmt/pull/3544>`_,
  `#3548 <https://github.com/fmtlib/fmt/issues/3548>`_,
  `#3549 <https://github.com/fmtlib/fmt/pull/3549>`_,
  `#3550 <https://github.com/fmtlib/fmt/pull/3550>`_,
  `#3552 <https://github.com/fmtlib/fmt/pull/3552>`_).
  Thanks `@adesitter (Arnaud Desitter) <https://github.com/adesitter>`_,
  `@hmbj (Hans-Martin B. Jensen) <https://github.com/hmbj>`_,
  `@Minty-Meeo <https://github.com/Minty-Meeo>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@TobiSchluter (Tobias Schlüter) <https://github.com/TobiSchluter>`_,
  `@kieranclancy (Kieran Clancy) <https://github.com/kieranclancy>`_,
  `@alexeedm (Dmitry Alexeev) <https://github.com/alexeedm>`_,
  `@jurihock (Jürgen Hock) <https://github.com/jurihock>`_,
  `@Ozomahtli <https://github.com/Ozomahtli>`_,
  `@razaqq <https://github.com/razaqq>`_.
 10.0.0 - 2023-05-09
 -------------------
 * Replaced Grisu with a new floating-point formatting algorithm for given
  precision (`#3262 <https://github.com/fmtlib/fmt/issues/3262>`_,
  `#2750 <https://github.com/fmtlib/fmt/issues/2750>`_,
  `#3269 <https://github.com/fmtlib/fmt/pull/3269>`_,
  `#3276 <https://github.com/fmtlib/fmt/pull/3276>`_).
  The new algorithm is based on Dragonbox already used for the
  shortest representation and gives substantial performance improvement:
  .. image:: https://user-images.githubusercontent.com/33922675/
             211956670-84891a09-6867-47d9-82fc-3230da7abe0f.png
  * Red: new algorithm
  * Green: new algorithm with ``FMT_USE_FULL_CACHE_DRAGONBOX`` defined to 1
  * Blue: old algorithm
  Thanks `@jk-jeon (Junekey Jeon) <https://github.com/jk-jeon>`_.
 * Replaced ``snprintf``-based hex float formatter with an internal
  implementation (`#3179 <https://github.com/fmtlib/fmt/pull/3179>`_,
  `#3203 <https://github.com/fmtlib/fmt/pull/3203>`_).
  This removes the last usage of ``s(n)printf`` in {fmt}.
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Fixed alignment of floating-point numbers with localization
  (`#3263 <https://github.com/fmtlib/fmt/issues/3263>`_,
  `#3272 <https://github.com/fmtlib/fmt/pull/3272>`_).
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Made handling of ``#`` consistent with ``std::format``.
 * Improved C++20 module support
  (`#3134 <https://github.com/fmtlib/fmt/pull/3134>`_,
  `#3254 <https://github.com/fmtlib/fmt/pull/3254>`_,
  `#3386 <https://github.com/fmtlib/fmt/pull/3386>`_,
  `#3387 <https://github.com/fmtlib/fmt/pull/3387>`_,
  `#3388 <https://github.com/fmtlib/fmt/pull/3388>`_,
  `#3392 <https://github.com/fmtlib/fmt/pull/3392>`_,
  `#3397 <https://github.com/fmtlib/fmt/pull/3397>`_,
  `#3399 <https://github.com/fmtlib/fmt/pull/3399>`_,
  `#3400 <https://github.com/fmtlib/fmt/pull/3400>`_).
  Thanks `@laitingsheng (Tinson Lai) <https://github.com/laitingsheng>`_,
  `@Orvid (Orvid King) <https://github.com/Orvid>`_,
  `@DanielaE (Daniela Engert) <https://github.com/DanielaE>`_.
  Switched to the `modules CMake library <https://github.com/vitaut/modules>`_
  which allows building {fmt} as a C++20 module with clang::
    CXX=clang++ cmake -DFMT_MODULE=ON .
    make
 * Made ``format_as`` work with any user-defined type and not just enums.
  For example (`godbolt <https://godbolt.org/z/b7rqhq5Kh>`__):
  .. code:: c++
     #include <fmt/format.h>
     struct floaty_mc_floatface {
       double value;
     };
     auto format_as(floaty_mc_floatface f) { return f.value; }
     int main() {
       fmt::print("{:8}\n", floaty_mc_floatface{0.42}); // prints "    0.42"
     }
 * Removed deprecated implicit conversions for enums and conversions to primitive
  types for compatibility with ``std::format`` and to prevent potential ODR
  violations. Use ``format_as`` instead.
 * Added support for fill, align and width to the time point formatter
  (`#3237 <https://github.com/fmtlib/fmt/issues/3237>`_,
  `#3260 <https://github.com/fmtlib/fmt/pull/3260>`_,
  `#3275 <https://github.com/fmtlib/fmt/pull/3275>`_).
  For example (`godbolt <https://godbolt.org/z/rKP6MGz6c>`__):
  .. code:: c++
     #include <fmt/chrono.h>
     int main() {
       // prints "    2023"
       fmt::print("{:>8%Y}\n", std::chrono::system_clock::now());
     }
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Implemented formatting of subseconds
  (`#2207 <https://github.com/fmtlib/fmt/issues/2207>`_,
  `#3117 <https://github.com/fmtlib/fmt/issues/3117>`_,
  `#3115 <https://github.com/fmtlib/fmt/pull/3115>`_,
  `#3143 <https://github.com/fmtlib/fmt/pull/3143>`_,
  `#3144 <https://github.com/fmtlib/fmt/pull/3144>`_,
  `#3349 <https://github.com/fmtlib/fmt/pull/3349>`_).
  For example (`godbolt <https://godbolt.org/z/45738oGEo>`__):
  .. code:: c++
     #include <fmt/chrono.h>
     int main() {
       // prints 01.234567
       fmt::print("{:%S}\n", std::chrono::microseconds(1234567));
     }
  Thanks `@patrickroocks (Patrick Roocks) <https://github.com/patrickroocks>`_
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.
 * Added precision support to ``%S``
  (`#3148 <https://github.com/fmtlib/fmt/pull/3148>`_).
  Thanks `@SappyJoy (Stepan Ponomaryov) <https://github.com/SappyJoy>`_
 * Added support for ``std::utc_time``
  (`#3098 <https://github.com/fmtlib/fmt/issues/3098>`_,
  `#3110 <https://github.com/fmtlib/fmt/pull/3110>`_).
  Thanks `@patrickroocks (Patrick Roocks) <https://github.com/patrickroocks>`_.
 * Switched formatting of ``std::chrono::system_clock`` from local time to UTC
  for compatibility with the standard
  (`#3199 <https://github.com/fmtlib/fmt/issues/3199>`_,
  `#3230 <https://github.com/fmtlib/fmt/pull/3230>`_).
  Thanks `@ned14 (Niall Douglas) <https://github.com/ned14>`_.
 * Added support for ``%Ez`` and ``%Oz`` to chrono formatters.
  (`#3220 <https://github.com/fmtlib/fmt/issues/3220>`_,
  `#3222 <https://github.com/fmtlib/fmt/pull/3222>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Improved validation of format specifiers for ``std::chrono::duration``
  (`#3219 <https://github.com/fmtlib/fmt/issues/3219>`_,
  `#3232 <https://github.com/fmtlib/fmt/pull/3232>`_).
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Fixed formatting of time points before the epoch
  (`#3117 <https://github.com/fmtlib/fmt/issues/3117>`_,
  `#3261 <https://github.com/fmtlib/fmt/pull/3261>`_).
  For example (`godbolt <https://godbolt.org/z/f7bcznb3W>`__):
  .. code:: c++
     #include <fmt/chrono.h>
     int main() {
       auto t = std::chrono::system_clock::from_time_t(0) -
                std::chrono::milliseconds(250);
       fmt::print("{:%S}\n", t); // prints 59.750000000
     }
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Experimental: implemented glibc extension for padding seconds, minutes and
  hours (`#2959 <https://github.com/fmtlib/fmt/issues/2959>`_,
  `#3271 <https://github.com/fmtlib/fmt/pull/3271>`_).
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Added a formatter for ``std::exception``
  (`#2977 <https://github.com/fmtlib/fmt/issues/2977>`_,
  `#3012 <https://github.com/fmtlib/fmt/issues/3012>`_,
  `#3062 <https://github.com/fmtlib/fmt/pull/3062>`_,
  `#3076 <https://github.com/fmtlib/fmt/pull/3076>`_,
  `#3119 <https://github.com/fmtlib/fmt/pull/3119>`_).
  For example (`godbolt <https://godbolt.org/z/8xoWGs9e4>`__):
  .. code:: c++
     #include <fmt/std.h>
     #include <vector>
     int main() {
       try {
         std::vector<bool>().at(0);
       } catch(const std::exception& e) {
         fmt::print("{}", e);
       }
     }
  prints::
    vector<bool>::_M_range_check: __n (which is 0) >= this->size() (which is 0)
  on libstdc++.
  Thanks `@zach2good (Zach Toogood) <https://github.com/zach2good>`_ and
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Moved ``std::error_code`` formatter from ``fmt/os.h`` to ``fmt/std.h``.
  (`#3125 <https://github.com/fmtlib/fmt/pull/3125>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Added formatters for standard container adapters: ``std::priority_queue``,
  ``std::queue`` and ``std::stack``
  (`#3215 <https://github.com/fmtlib/fmt/issues/3215>`_,
  `#3279 <https://github.com/fmtlib/fmt/pull/3279>`_).
  For example (`godbolt <https://godbolt.org/z/74h1xY9qK>`__):
  .. code:: c++
     #include <fmt/ranges.h>
     #include <stack>
     #include <vector>
     int main() {
       auto s = std::stack<bool, std::vector<bool>>();
       for (auto b: {true, false, true}) s.push(b);
       fmt::print("{}\n", s); // prints [true, false, true]
     }
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Added a formatter for ``std::optional`` to ``fmt/std.h``.
  Thanks `@tom-huntington <https://github.com/tom-huntington>`_.
 * Fixed formatting of valueless by exception variants
  (`#3347 <https://github.com/fmtlib/fmt/pull/3347>`_).
  Thanks `@TheOmegaCarrot <https://github.com/TheOmegaCarrot>`_.
 * Made ``fmt::ptr`` accept ``unique_ptr`` with a custom deleter
  (`#3177 <https://github.com/fmtlib/fmt/pull/3177>`_).
  Thanks `@hmbj (Hans-Martin B. Jensen) <https://github.com/hmbj>`_.
 * Fixed formatting of noncopyable ranges and nested ranges of chars
  (`#3158 <https://github.com/fmtlib/fmt/pull/3158>`_
  `#3286 <https://github.com/fmtlib/fmt/issues/3286>`_,
  `#3290 <https://github.com/fmtlib/fmt/pull/3290>`_).
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.
 * Fixed issues with formatting of paths and ranges of paths
  (`#3319 <https://github.com/fmtlib/fmt/issues/3319>`_,
  `#3321 <https://github.com/fmtlib/fmt/pull/3321>`_
  `#3322 <https://github.com/fmtlib/fmt/issues/3322>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Improved handling of invalid Unicode in paths.
 * Enabled compile-time checks on Apple clang 14 and later
  (`#3331 <https://github.com/fmtlib/fmt/pull/3331>`_).
  Thanks `@cloyce (Cloyce D. Spradling) <https://github.com/cloyce>`_.
 * Improved compile-time checks of named arguments
  (`#3105 <https://github.com/fmtlib/fmt/issues/3105>`_,
  `#3214 <https://github.com/fmtlib/fmt/pull/3214>`_).
  Thanks `@rbrich (Radek Brich) <https://github.com/rbrich>`_.
 * Fixed formatting when both alignment and ``0`` are given
  (`#3236 <https://github.com/fmtlib/fmt/issues/3236>`_,
  `#3248 <https://github.com/fmtlib/fmt/pull/3248>`_).
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Improved Unicode support in the experimental file API on Windows
  (`#3234 <https://github.com/fmtlib/fmt/issues/3234>`_,
  `#3293 <https://github.com/fmtlib/fmt/pull/3293>`_).
  Thanks `@Fros1er (Froster) <https://github.com/Fros1er>`_.
 * Unified UTF transcoding
  (`#3416 <https://github.com/fmtlib/fmt/pull/3416>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Added support for UTF-8 digit separators via an experimental locale facet
  (`#1861 <https://github.com/fmtlib/fmt/issues/1861>`_).
  For example (`godbolt <https://godbolt.org/z/f7bcznb3W>`__):
  .. code:: c++
     auto loc = std::locale(
       std::locale(), new fmt::format_facet<std::locale>("’"));
     auto s = fmt::format(loc, "{:L}", 1000);
  where ``’`` is U+2019 used as a digit separator in the de_CH locale.
 * Added an overload of ``formatted_size`` that takes a locale
  (`#3084 <https://github.com/fmtlib/fmt/issues/3084>`_,
  `#3087 <https://github.com/fmtlib/fmt/pull/3087>`_).
  Thanks `@gerboengels <https://github.com/gerboengels>`_.
 * Removed the deprecated ``FMT_DEPRECATED_OSTREAM``.
 * Fixed a UB when using a null ``std::string_view`` with ``fmt::to_string``
  or format string compilation
  (`#3241 <https://github.com/fmtlib/fmt/issues/3241>`_,
  `#3244 <https://github.com/fmtlib/fmt/pull/3244>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Added ``starts_with`` to the fallback ``string_view`` implementation
  (`#3080 <https://github.com/fmtlib/fmt/pull/3080>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Added ``fmt::basic_format_string::get()`` for compatibility with
  ``basic_format_string`` (`#3111 <https://github.com/fmtlib/fmt/pull/3111>`_).
  Thanks `@huangqinjin <https://github.com/huangqinjin>`_.
 * Added ``println`` for compatibility with C++23
  (`#3267 <https://github.com/fmtlib/fmt/pull/3267>`_).
  Thanks `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_.
 * Renamed the ``FMT_EXPORT`` macro for shared library usage to
  ``FMT_LIB_EXPORT``.
 * Improved documentation
  (`#3108 <https://github.com/fmtlib/fmt/issues/3108>`_,
  `#3169 <https://github.com/fmtlib/fmt/issues/3169>`_,
  `#3243 <https://github.com/fmtlib/fmt/pull/3243>`_).
  `#3404 <https://github.com/fmtlib/fmt/pull/3404>`_).
  Thanks `@Cleroth <https://github.com/Cleroth>`_ and
  `@Vertexwahn <https://github.com/Vertexwahn>`_.
 * Improved build configuration and tests
  (`#3118 <https://github.com/fmtlib/fmt/pull/3118>`_,
  `#3120 <https://github.com/fmtlib/fmt/pull/3120>`_,
  `#3188 <https://github.com/fmtlib/fmt/pull/3188>`_,
  `#3189 <https://github.com/fmtlib/fmt/issues/3189>`_,
  `#3198 <https://github.com/fmtlib/fmt/pull/3198>`_,
  `#3205 <https://github.com/fmtlib/fmt/pull/3205>`_,
  `#3207 <https://github.com/fmtlib/fmt/pull/3207>`_,
  `#3210 <https://github.com/fmtlib/fmt/pull/3210>`_,
  `#3240 <https://github.com/fmtlib/fmt/pull/3240>`_,
  `#3256 <https://github.com/fmtlib/fmt/pull/3256>`_,
  `#3264 <https://github.com/fmtlib/fmt/pull/3264>`_,
  `#3299 <https://github.com/fmtlib/fmt/issues/3299>`_,
  `#3302 <https://github.com/fmtlib/fmt/pull/3302>`_,
  `#3312 <https://github.com/fmtlib/fmt/pull/3312>`_,
  `#3317 <https://github.com/fmtlib/fmt/issues/3317>`_,
  `#3328 <https://github.com/fmtlib/fmt/pull/3328>`_,
  `#3333 <https://github.com/fmtlib/fmt/pull/3333>`_,
  `#3369 <https://github.com/fmtlib/fmt/pull/3369>`_,
  `#3373 <https://github.com/fmtlib/fmt/issues/3373>`_,
  `#3395 <https://github.com/fmtlib/fmt/pull/3395>`_,
  `#3406 <https://github.com/fmtlib/fmt/pull/3406>`_,
  `#3411 <https://github.com/fmtlib/fmt/pull/3411>`_).
  Thanks `@dimztimz (Dimitrij Mijoski) <https://github.com/dimztimz>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@DavidKorczynski <https://github.com/DavidKorczynski>`_,
  `@ChrisThrasher (Chris Thrasher) <https://github.com/ChrisThrasher>`_,
  `@FrancoisCarouge (François Carouge) <https://github.com/FrancoisCarouge>`_,
  `@kennyweiss (Kenny Weiss) <https://github.com/kennyweiss>`_,
  `@luzpaz <https://github.com/luzpaz>`_,
  `@codeinred (Alecto Irene Perez) <https://github.com/codeinred>`_,
  `@Mixaill (Mikhail Paulyshka) <https://github.com/Mixaill>`_,
  `@joycebrum (Joyce) <https://github.com/joycebrum>`_,
  `@kevinhwang (Kevin Hwang) <https://github.com/kevinhwang>`_,
  `@Vertexwahn <https://github.com/Vertexwahn>`_.
 * Fixed a regression in handling empty format specifiers after a colon (``{:}``)
  (`#3086 <https://github.com/fmtlib/fmt/pull/3086>`_).
  Thanks `@oxidase (Michael Krasnyk) <https://github.com/oxidase>`_.
 * Worked around a broken implementation of ``std::is_constant_evaluated`` in
  some versions of libstdc++ on clang
  (`#3247 <https://github.com/fmtlib/fmt/issues/3247>`_,
  `#3281 <https://github.com/fmtlib/fmt/pull/3281>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Fixed formatting of volatile variables
  (`#3068 <https://github.com/fmtlib/fmt/pull/3068>`_).
 * Fixed various warnings and compilation issues
  (`#3057 <https://github.com/fmtlib/fmt/pull/3057>`_,
  `#3066 <https://github.com/fmtlib/fmt/pull/3066>`_,
  `#3072 <https://github.com/fmtlib/fmt/pull/3072>`_,
  `#3082 <https://github.com/fmtlib/fmt/pull/3082>`_,
  `#3091 <https://github.com/fmtlib/fmt/pull/3091>`_,
  `#3092 <https://github.com/fmtlib/fmt/issues/3092>`_,
  `#3093 <https://github.com/fmtlib/fmt/pull/3093>`_,
  `#3095 <https://github.com/fmtlib/fmt/pull/3095>`_,
  `#3096 <https://github.com/fmtlib/fmt/issues/3096>`_,
  `#3097 <https://github.com/fmtlib/fmt/pull/3097>`_,
  `#3128 <https://github.com/fmtlib/fmt/issues/3128>`_,
  `#3129 <https://github.com/fmtlib/fmt/pull/3129>`_,
  `#3137 <https://github.com/fmtlib/fmt/pull/3137>`_,
  `#3139 <https://github.com/fmtlib/fmt/pull/3139>`_,
  `#3140 <https://github.com/fmtlib/fmt/issues/3140>`_,
  `#3142 <https://github.com/fmtlib/fmt/pull/3142>`_,
  `#3149 <https://github.com/fmtlib/fmt/issues/3149>`_,
  `#3150 <https://github.com/fmtlib/fmt/pull/3150>`_,
  `#3154 <https://github.com/fmtlib/fmt/issues/3154>`_,
  `#3163 <https://github.com/fmtlib/fmt/issues/3163>`_,
  `#3178 <https://github.com/fmtlib/fmt/issues/3178>`_,
  `#3184 <https://github.com/fmtlib/fmt/pull/3184>`_,
  `#3196 <https://github.com/fmtlib/fmt/pull/3196>`_,
  `#3204 <https://github.com/fmtlib/fmt/issues/3204>`_,
  `#3206 <https://github.com/fmtlib/fmt/pull/3206>`_,
  `#3208 <https://github.com/fmtlib/fmt/pull/3208>`_,
  `#3213 <https://github.com/fmtlib/fmt/issues/3213>`_,
  `#3216 <https://github.com/fmtlib/fmt/pull/3216>`_,
  `#3224 <https://github.com/fmtlib/fmt/issues/3224>`_,
  `#3226 <https://github.com/fmtlib/fmt/issues/3226>`_,
  `#3228 <https://github.com/fmtlib/fmt/issues/3228>`_,
  `#3229 <https://github.com/fmtlib/fmt/pull/3229>`_,
  `#3259 <https://github.com/fmtlib/fmt/pull/3259>`_,
  `#3274 <https://github.com/fmtlib/fmt/issues/3274>`_,
  `#3287 <https://github.com/fmtlib/fmt/issues/3287>`_,
  `#3288 <https://github.com/fmtlib/fmt/pull/3288>`_,
  `#3292 <https://github.com/fmtlib/fmt/issues/3292>`_,
  `#3295 <https://github.com/fmtlib/fmt/pull/3295>`_,
  `#3296 <https://github.com/fmtlib/fmt/pull/3296>`_,
  `#3298 <https://github.com/fmtlib/fmt/issues/3298>`_,
  `#3325 <https://github.com/fmtlib/fmt/issues/3325>`_,
  `#3326 <https://github.com/fmtlib/fmt/pull/3326>`_,
  `#3334 <https://github.com/fmtlib/fmt/issues/3334>`_,
  `#3342 <https://github.com/fmtlib/fmt/issues/3342>`_,
  `#3343 <https://github.com/fmtlib/fmt/pull/3343>`_,
  `#3351 <https://github.com/fmtlib/fmt/issues/3351>`_,
  `#3352 <https://github.com/fmtlib/fmt/pull/3352>`_,
  `#3362 <https://github.com/fmtlib/fmt/pull/3362>`_,
  `#3365 <https://github.com/fmtlib/fmt/issues/3365>`_,
  `#3366 <https://github.com/fmtlib/fmt/pull/3366>`_,
  `#3374 <https://github.com/fmtlib/fmt/pull/3374>`_,
  `#3377 <https://github.com/fmtlib/fmt/issues/3377>`_,
  `#3378 <https://github.com/fmtlib/fmt/pull/3378>`_,
  `#3381 <https://github.com/fmtlib/fmt/issues/3381>`_,
  `#3398 <https://github.com/fmtlib/fmt/pull/3398>`_,
  `#3413 <https://github.com/fmtlib/fmt/pull/3413>`_,
  `#3415 <https://github.com/fmtlib/fmt/issues/3415>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_,
  `@gsjaardema (Greg Sjaardema) <https://github.com/gsjaardema>`_,
  `@NewbieOrange <https://github.com/NewbieOrange>`_,
  `@EngineLessCC (VivyaCC) <https://github.com/EngineLessCC>`_,
  `@asmaloney (Andy Maloney) <https://github.com/asmaloney>`_,
  `@HazardyKnusperkeks (Björn Schäpers)
  <https://github.com/HazardyKnusperkeks>`_,
  `@sergiud (Sergiu Deitsch) <https://github.com/sergiud>`_,
  `@Youw (Ihor Dutchak) <https://github.com/Youw>`_,
  `@thesmurph <https://github.com/thesmurph>`_,
  `@czudziakm (Maksymilian Czudziak) <https://github.com/czudziakm>`_,
  `@Roman-Koshelev <https://github.com/Roman-Koshelev>`_,
  `@chronoxor (Ivan Shynkarenka) <https://github.com/chronoxor>`_,
  `@ShawnZhong (Shawn Zhong) <https://github.com/ShawnZhong>`_,
  `@russelltg (Russell Greene) <https://github.com/russelltg>`_,
  `@glebm (Gleb Mazovetskiy) <https://github.com/glebm>`_,
  `@tmartin-gh <https://github.com/tmartin-gh>`_,
  `@Zhaojun-Liu (June Liu) <https://github.com/Zhaojun-Liu>`_,
  `@louiswins (Louis Wilson) <https://github.com/louiswins>`_,
  `@mogemimi <https://github.com/mogemimi>`_.
 9.1.0 - 2022-08-27
 ------------------
 * ``fmt::formatted_size`` now works at compile time
  (`#3026 <https://github.com/fmtlib/fmt/pull/3026>`_). For example
  (`godbolt <https://godbolt.org/z/1MW5rMdf8>`__):
  .. code:: c++
     #include <fmt/compile.h>
     int main() {
       using namespace fmt::literals;
       constexpr size_t n = fmt::formatted_size("{}"_cf, 42);
       fmt::print("{}\n", n); // prints 2
     }
  Thanks `@marksantaniello (Mark Santaniello)
  <https://github.com/marksantaniello>`_.
 * Fixed handling of invalid UTF-8 
  (`#3038 <https://github.com/fmtlib/fmt/pull/3038>`_,
  `#3044 <https://github.com/fmtlib/fmt/pull/3044>`_,
  `#3056 <https://github.com/fmtlib/fmt/pull/3056>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_ and
  `@skeeto (Christopher Wellons) <https://github.com/skeeto>`_.
 * Improved Unicode support in ``ostream`` overloads of ``print``
  (`#2994 <https://github.com/fmtlib/fmt/pull/2994>`_,
  `#3001 <https://github.com/fmtlib/fmt/pull/3001>`_,
  `#3025 <https://github.com/fmtlib/fmt/pull/3025>`_).
  Thanks `@dimztimz (Dimitrij Mijoski) <https://github.com/dimztimz>`_.
 * Fixed handling of the sign specifier in localized formatting on systems with
  32-bit ``wchar_t`` (`#3041 <https://github.com/fmtlib/fmt/issues/3041>`_).
 * Added support for wide streams to ``fmt::streamed``
  (`#2994 <https://github.com/fmtlib/fmt/pull/2994>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Added the ``n`` specifier that disables the output of delimiters when
  formatting ranges (`#2981 <https://github.com/fmtlib/fmt/pull/2981>`_,
  `#2983 <https://github.com/fmtlib/fmt/pull/2983>`_).
  For example (`godbolt <https://godbolt.org/z/roKqGdj8c>`__):
  .. code:: c++
     #include <fmt/ranges.h>
     #include <vector>
     int main() {
       auto v = std::vector{1, 2, 3};
       fmt::print("{:n}\n", v); // prints 1, 2, 3
     }
  Thanks `@BRevzin (Barry Revzin) <https://github.com/BRevzin>`_.
 * Worked around problematic ``std::string_view`` constructors introduced in
  C++23 (`#3030 <https://github.com/fmtlib/fmt/issues/3030>`_,
  `#3050 <https://github.com/fmtlib/fmt/issues/3050>`_).
  Thanks `@strega-nil-ms (nicole mazzuca) <https://github.com/strega-nil-ms>`_.
 * Improve handling (exclusion) of recursive ranges
  (`#2968 <https://github.com/fmtlib/fmt/issues/2968>`_,
  `#2974 <https://github.com/fmtlib/fmt/pull/2974>`_).
  Thanks `@Dani-Hub (Daniel Krügler) <https://github.com/Dani-Hub>`_.
 * Improved error reporting in format string compilation
  (`#3055 <https://github.com/fmtlib/fmt/issues/3055>`_).
 * Improved the implementation of
  `Dragonbox <https://github.com/jk-jeon/dragonbox>`_, the algorithm used for
  the default floating-point formatting
  (`#2984 <https://github.com/fmtlib/fmt/pull/2984>`_).
  Thanks `@jk-jeon (Junekey Jeon) <https://github.com/jk-jeon>`_.
 * Fixed issues with floating-point formatting on exotic platforms.
 * Improved the implementation of chrono formatting
  (`#3010 <https://github.com/fmtlib/fmt/pull/3010>`_).
  Thanks `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 * Improved documentation
  (`#2966 <https://github.com/fmtlib/fmt/pull/2966>`_,
  `#3009 <https://github.com/fmtlib/fmt/pull/3009>`_,
  `#3020 <https://github.com/fmtlib/fmt/issues/3020>`_,
  `#3037 <https://github.com/fmtlib/fmt/pull/3037>`_).
  Thanks `@mwinterb <https://github.com/mwinterb>`_,
  `@jcelerier (Jean-Michaël Celerier) <https://github.com/jcelerier>`_
  and `@remiburtin (Rémi Burtin) <https://github.com/remiburtin>`_.
 * Improved build configuration
  (`#2991 <https://github.com/fmtlib/fmt/pull/2991>`_,
  `#2995 <https://github.com/fmtlib/fmt/pull/2995>`_,
  `#3004 <https://github.com/fmtlib/fmt/issues/3004>`_,
  `#3007 <https://github.com/fmtlib/fmt/pull/3007>`_,
  `#3040 <https://github.com/fmtlib/fmt/pull/3040>`_).
  Thanks `@dimztimz (Dimitrij Mijoski) <https://github.com/dimztimz>`_ and
  `@hwhsu1231 (Haowei Hsu) <https://github.com/hwhsu1231>`_.
 * Fixed various warnings and compilation issues
  (`#2969 <https://github.com/fmtlib/fmt/issues/2969>`_,
  `#2971 <https://github.com/fmtlib/fmt/pull/2971>`_,
  `#2975 <https://github.com/fmtlib/fmt/issues/2975>`_,
  `#2982 <https://github.com/fmtlib/fmt/pull/2982>`_,
  `#2985 <https://github.com/fmtlib/fmt/pull/2985>`_,
  `#2988 <https://github.com/fmtlib/fmt/issues/2988>`_,
  `#2989 <https://github.com/fmtlib/fmt/issues/2989>`_,
  `#3000 <https://github.com/fmtlib/fmt/issues/3000>`_,
  `#3006 <https://github.com/fmtlib/fmt/issues/3006>`_,
  `#3014 <https://github.com/fmtlib/fmt/issues/3014>`_,
  `#3015 <https://github.com/fmtlib/fmt/issues/3015>`_,
  `#3021 <https://github.com/fmtlib/fmt/pull/3021>`_,
  `#3023 <https://github.com/fmtlib/fmt/issues/3023>`_,
  `#3024 <https://github.com/fmtlib/fmt/pull/3024>`_,
  `#3029 <https://github.com/fmtlib/fmt/pull/3029>`_,
  `#3043 <https://github.com/fmtlib/fmt/pull/3043>`_,
  `#3052 <https://github.com/fmtlib/fmt/issues/3052>`_,
  `#3053 <https://github.com/fmtlib/fmt/pull/3053>`_,
  `#3054 <https://github.com/fmtlib/fmt/pull/3054>`_).
  Thanks `@h-friederich (Hannes Friederich) <https://github.com/h-friederich>`_,
  `@dimztimz (Dimitrij Mijoski) <https://github.com/dimztimz>`_,
  `@olupton (Olli Lupton) <https://github.com/olupton>`_,
  `@bernhardmgruber (Bernhard Manfred Gruber)
  <https://github.com/bernhardmgruber>`_,
  `@phprus (Vladislav Shchapov) <https://github.com/phprus>`_.
 9.0.0 - 2022-07-04
 ------------------
@ -19,7 +812,7 @@
       return result;
     }
-     constexpr auto answer = compile_time_itoa(0.42);
+     constexpr auto answer = compile_time_dtoa(0.42);
  works with the default settings.
@ -2134,7 +2927,7 @@
  <https://github.com/kwesolowski>`_.
 * Replaced ``FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION`` with the ``FMT_FUZZ``
-  macro to prevent interferring with fuzzing of projects using {fmt}
+  macro to prevent interfering with fuzzing of projects using {fmt}
  (`#1650 <https://github.com/fmtlib/fmt/pull/1650>`_).
  Thanks `@asraa (Asra Ali) <https://github.com/asraa>`_.
--- a/dep/fmt/LICENSE.rst
+++ b/dep/fmt/LICENSE.rst
@ -1,4 +1,4 @@
-Copyright (c) 2012 - present, Victor Zverovich
+Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/dep/fmt/README.rst
+++ b/dep/fmt/README.rst
@ -12,9 +12,6 @@
 .. image:: https://github.com/fmtlib/fmt/workflows/windows/badge.svg
   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows
 .. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v?svg=true
   :target: https://ci.appveyor.com/project/vitaut/fmt
 .. image:: https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg
   :alt: fmt is continuously fuzzed at oss-fuzz
   :target: https://bugs.chromium.org/p/oss-fuzz/issues/list?\
@ -25,6 +22,9 @@
   :alt: Ask questions at StackOverflow with the tag fmt
   :target: https://stackoverflow.com/questions/tagged/fmt
 .. image:: https://api.securityscorecards.dev/projects/github.com/fmtlib/fmt/badge
   :target: https://securityscorecards.dev/viewer/?uri=github.com/fmtlib/fmt
 **{fmt}** is an open-source formatting library providing a fast and safe
 alternative to C stdio and C++ iostreams.
@ -50,7 +50,9 @@ Features
 * `Format string syntax <https://fmt.dev/latest/syntax.html>`_ similar to Python's
  `format <https://docs.python.org/3/library/stdtypes.html#str.format>`_
 * Fast IEEE 754 floating-point formatter with correct rounding, shortness and
-  round-trip guarantees
+  round-trip guarantees using the `Dragonbox <https://github.com/jk-jeon/dragonbox>`_
  algorithm
 * Portable Unicode support
 * Safe `printf implementation
  <https://fmt.dev/latest/api.html#printf-formatting>`_ including the POSIX
  extension for positional arguments
@ -67,7 +69,7 @@ Features
  <https://github.com/fmtlib/fmt/tree/master/test>`_ and is `continuously fuzzed
  <https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20
  Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1>`_
-* Safety: the library is fully type safe, errors in format strings can be
+* Safety: the library is fully type-safe, errors in format strings can be
  reported at compile time, automatic memory management prevents buffer overflow
  errors
 * Ease of use: small self-contained code base, no external dependencies,
@ -77,7 +79,7 @@ Features
  consistent output across platforms and support for older compilers
 * Clean warning-free codebase even on high warning levels such as
  ``-Wall -Wextra -pedantic``
-* Locale-independence by default
+* Locale independence by default
 * Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro
 See the `documentation <https://fmt.dev>`_ for more details.
@ -194,24 +196,24 @@ Speed tests
 ================= ============= ===========
 Library           Method        Run Time, s
 ================= ============= ===========
-libc              printf          1.04
+libc              printf          0.91
-libc++            std::ostream    3.05
+libc++            std::ostream    2.49
-{fmt} 6.1.1       fmt::print      0.75
+{fmt} 9.1         fmt::print      0.74
-Boost Format 1.67 boost::format   7.24
+Boost Format 1.80 boost::format   6.26
-Folly Format      folly::format   2.23
+Folly Format      folly::format   1.87
 ================= ============= ===========
-{fmt} is the fastest of the benchmarked methods, ~35% faster than ``printf``.
+{fmt} is the fastest of the benchmarked methods, ~20% faster than ``printf``.
 The above results were generated by building ``tinyformat_test.cpp`` on macOS
-10.14.6 with ``clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT``, and taking the
+12.6.1 with ``clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT``, and taking the
 best of three runs. In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"``
 or equivalent is filled 2,000,000 times with output sent to ``/dev/null``; for
 further details refer to the `source
 <https://github.com/fmtlib/format-benchmark/blob/master/src/tinyformat-test.cc>`_.
 {fmt} is up to 20-30x faster than ``std::ostringstream`` and ``sprintf`` on
-floating-point formatting (`dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_)
+IEEE754 ``float`` and ``double`` formatting (`dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_)
 and faster than `double-conversion <https://github.com/google/double-conversion>`_ and
 `ryu <https://github.com/ulfjack/ryu>`_:
@ -227,7 +229,7 @@ The script `bloat-test.py
 from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_
 tests compile time and code bloat for nontrivial projects.
 It generates 100 translation units and uses ``printf()`` or its alternative
-five times in each to simulate a medium sized project.  The resulting
+five times in each to simulate a medium-sized project.  The resulting
 executable size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42),
 macOS Sierra, best of three) is shown in the following tables.
@ -248,7 +250,7 @@ As you can see, {fmt} has 60% less overhead in terms of resulting binary code
 size compared to iostreams and comes pretty close to ``printf``. Boost Format
 and Folly Format have the largest overheads.
-``printf+string`` is the same as ``printf`` but with extra ``<string>``
+``printf+string`` is the same as ``printf`` but with an extra ``<string>``
 include to measure the overhead of the latter.
 **Non-optimized build**
@ -264,14 +266,14 @@ Boost Format             54.1                  365                303
 Folly Format             79.9                  445                430
 ============= =============== ==================== ==================
-``libc``, ``lib(std)c++`` and ``libfmt`` are all linked as shared libraries to
+``libc``, ``lib(std)c++``, and ``libfmt`` are all linked as shared libraries to
 compare formatting function overhead only. Boost Format is a
 header-only library so it doesn't provide any linkage options.
 Running the tests
 ~~~~~~~~~~~~~~~~~
-Please refer to `Building the library`__ for the instructions on how to build
+Please refer to `Building the library`__ for instructions on how to build
 the library and run the unit tests.
 __ https://fmt.dev/latest/usage.html#building-the-library
@ -296,9 +298,12 @@ or the bloat test::
 Migrating code
 --------------
-`clang-tidy-fmt <https://github.com/mikecrowe/clang-tidy-fmt>`_ provides clang
+`clang-tidy <https://clang.llvm.org/extra/clang-tidy/>`_ v17 (not yet
-tidy checks for converting occurrences of ``printf`` and ``fprintf`` to
+released) provides the `modernize-use-std-print
-``fmt::print``.
+<https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-std-print.html>`_
 check that is capable of converting occurrences of ``printf`` and
 ``fprintf`` to ``fmt::print`` if configured to do so. (By default it
 converts to ``std::print``.)
 Projects using this library
 ---------------------------
@ -306,8 +311,6 @@ Projects using this library
 * `0 A.D. <https://play0ad.com/>`_: a free, open-source, cross-platform
  real-time strategy game
 * `2GIS <https://2gis.ru/>`_: free business listings with a city map
 * `AMPL/MP <https://github.com/ampl/mp>`_:
  an open-source library for mathematical programming
@ -325,8 +328,10 @@ Projects using this library
 * `ccache <https://ccache.dev/>`_: a compiler cache
-* `ClickHouse <https://github.com/ClickHouse/ClickHouse>`_: analytical database
+* `ClickHouse <https://github.com/ClickHouse/ClickHouse>`_: an analytical database
  management system
 * `Contour <https://github.com/contour-terminal/contour/>`_: a modern terminal emulator
 * `CUAUV <https://cuauv.org/>`_: Cornell University's autonomous underwater
  vehicle
@ -363,6 +368,10 @@ Projects using this library
 * `Knuth <https://kth.cash/>`_: high-performance Bitcoin full-node
 * `libunicode <https://github.com/contour-terminal/libunicode/>`_: a modern C++17 Unicode library
 * `MariaDB <https://mariadb.org/>`_: relational database management system
 * `Microsoft Verona <https://github.com/microsoft/verona>`_:
  research programming language for concurrent ownership
@ -392,7 +401,7 @@ Projects using this library
  proxy
 * `redpanda <https://vectorized.io/redpanda>`_: a 10x faster Kafka® replacement
-  for mission critical systems written in C++
+  for mission-critical systems written in C++
 * `rpclib <http://rpclib.net/>`_: a modern C++ msgpack-RPC server and client
  library
@ -416,6 +425,9 @@ Projects using this library
 * `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: open-source
  MMORPG framework
 * `🐙 userver framework <https://userver.tech/>`_: open-source asynchronous
  framework with a rich set of abstractions and database drivers
 * `Windows Terminal <https://github.com/microsoft/terminal>`_: the new Windows
  terminal
@ -473,7 +485,7 @@ error handling is awkward.
 Boost Format
 ~~~~~~~~~~~~
-This is a very powerful library which supports both ``printf``-like format
+This is a very powerful library that supports both ``printf``-like format
 strings and positional arguments. Its main drawback is performance. According to
 various benchmarks, it is much slower than other methods considered here. Boost
 Format also has excessive build times and severe code bloat issues (see
@ -482,7 +494,7 @@ Format also has excessive build times and severe code bloat issues (see
 FastFormat
 ~~~~~~~~~~
-This is an interesting library which is fast, safe and has positional arguments.
+This is an interesting library that is fast, safe, and has positional arguments.
 However, it has significant limitations, citing its author:
    Three features that have no hope of being accommodated within the
@ -498,7 +510,7 @@ restrictive for using it in some projects.
 Boost Spirit.Karma
 ~~~~~~~~~~~~~~~~~~
-This is not really a formatting library but I decided to include it here for
+This is not a formatting library but I decided to include it here for
 completeness. As iostreams, it suffers from the problem of mixing verbatim text
 with arguments. The library is pretty fast, but slower on integer formatting
 than ``fmt::format_to`` with format string compilation on Karma's own benchmark,
@ -517,7 +529,7 @@ Documentation License
 The `Format String Syntax <https://fmt.dev/latest/syntax.html>`_
 section in the documentation is based on the one from Python `string module
 documentation <https://docs.python.org/3/library/string.html#module-string>`_.
-For this reason the documentation is distributed under the Python Software
+For this reason, the documentation is distributed under the Python Software
 Foundation license available in `doc/python-license.txt
 <https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_.
 It only applies if you distribute the documentation of {fmt}.
@ -526,8 +538,7 @@ Maintainers
 -----------
 The {fmt} library is maintained by Victor Zverovich (`vitaut
-<https://github.com/vitaut>`_) and Jonathan Müller (`foonathan
+<https://github.com/vitaut>`_) with contributions from many other people.
 <https://github.com/foonathan>`_) with contributions from many other people.
 See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and
 `Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names.
 Let us know if your contribution is not listed or mentioned incorrectly and
--- a/dep/fmt/include/fmt/args.h
+++ b/dep/fmt/include/fmt/args.h
@ -1,4 +1,4 @@
-// Formatting library for C++ - dynamic format arguments
+// Formatting library for C++ - dynamic argument lists
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
--- a/dep/fmt/include/fmt/chrono.h
+++ b/dep/fmt/include/fmt/chrono.h
--- a/dep/fmt/include/fmt/color.h
+++ b/dep/fmt/include/fmt/color.h
@ -11,7 +11,7 @@
 #include "format.h"
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 enum class color : uint32_t {
  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@ -203,7 +203,7 @@ struct rgb {
  uint8_t b;
 };
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
@ -225,8 +225,7 @@ struct color_type {
    uint32_t rgb_color;
  } value;
 };
-
+}  // namespace detail
 FMT_END_DETAIL_NAMESPACE
 /** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
@ -323,7 +322,7 @@ FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
  return text_style(lhs) | rhs;
 }
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 template <typename Char> struct ansi_color_escape {
  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
@ -423,26 +422,6 @@ FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
  return ansi_color_escape<Char>(em);
 }
 template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
  int result = std::fputs(chars, stream);
  if (result < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
  int result = std::fputws(chars, stream);
  if (result < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 template <typename Char> inline void reset_color(FILE* stream) {
  fputs("\x1b[0m", stream);
 }
 template <> inline void reset_color<wchar_t>(FILE* stream) {
  fputs(L"\x1b[0m", stream);
 }
 template <typename Char> inline void reset_color(buffer<Char>& buffer) {
  auto reset_color = string_view("\x1b[0m");
  buffer.append(reset_color.begin(), reset_color.end());
@ -477,19 +456,21 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
  if (has_style) detail::reset_color<Char>(buf);
 }
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
-template <typename S, typename Char = char_t<S>>
+inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
-void vprint(std::FILE* f, const text_style& ts, const S& format,
+                   format_args args) {
-            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  // Legacy wide streams are not supported.
-  basic_memory_buffer<Char> buf;
+  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+  detail::vformat_to(buf, ts, fmt, args);
  if (detail::is_utf8()) {
-    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+    detail::print(f, string_view(buf.begin(), buf.size()));
-  } else {
+    return;
    buf.push_back(Char(0));
    detail::fputs(buf.data(), f);
  }
  buf.push_back('\0');
  int result = std::fputs(buf.data(), f);
  if (result < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 /**
@ -566,7 +547,7 @@ OutputIt vformat_to(
    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  auto&& buf = detail::get_buffer<Char>(out);
  detail::vformat_to(buf, ts, format_str, args);
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 /**
@ -634,7 +615,7 @@ struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
  **Example**::
-    fmt::print("Elapsed time: {s:.2f} seconds",
+    fmt::print("Elapsed time: {0:.2f} seconds",
               fmt::styled(1.23, fmt::fg(fmt::color::green) |
                                 fmt::bg(fmt::color::blue)));
  \endrst
@ -645,7 +626,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_COLOR_H_
--- a/dep/fmt/include/fmt/compile.h
+++ b/dep/fmt/include/fmt/compile.h
@ -14,89 +14,11 @@ FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename Char, typename InputIt>
-inline counting_iterator copy_str(InputIt begin, InputIt end,
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                  counting_iterator it) {
+                                                counting_iterator it) {
  return it + (end - begin);
 }
 template <typename OutputIt> class truncating_iterator_base {
 protected:
  OutputIt out_;
  size_t limit_;
  size_t count_ = 0;
  truncating_iterator_base() : out_(), limit_(0) {}
  truncating_iterator_base(OutputIt out, size_t limit)
      : out_(out), limit_(limit) {}
 public:
  using iterator_category = std::output_iterator_tag;
  using value_type = typename std::iterator_traits<OutputIt>::value_type;
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
  OutputIt base() const { return out_; }
  size_t count() const { return count_; }
 };
 // An output iterator that truncates the output and counts the number of objects
 // written to it.
 template <typename OutputIt,
          typename Enable = typename std::is_void<
              typename std::iterator_traits<OutputIt>::value_type>::type>
 class truncating_iterator;
 template <typename OutputIt>
 class truncating_iterator<OutputIt, std::false_type>
    : public truncating_iterator_base<OutputIt> {
  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
 public:
  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
  truncating_iterator() = default;
  truncating_iterator(OutputIt out, size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}
  truncating_iterator& operator++() {
    if (this->count_++ < this->limit_) ++this->out_;
    return *this;
  }
  truncating_iterator operator++(int) {
    auto it = *this;
    ++*this;
    return it;
  }
  value_type& operator*() const {
    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
  }
 };
 template <typename OutputIt>
 class truncating_iterator<OutputIt, std::true_type>
    : public truncating_iterator_base<OutputIt> {
 public:
  truncating_iterator() = default;
  truncating_iterator(OutputIt out, size_t limit)
      : truncating_iterator_base<OutputIt>(out, limit) {}
  template <typename T> truncating_iterator& operator=(T val) {
    if (this->count_++ < this->limit_) *this->out_++ = val;
    return *this;
  }
  truncating_iterator& operator++() { return *this; }
  truncating_iterator& operator++(int) { return *this; }
  truncating_iterator& operator*() { return *this; }
 };
 // A compile-time string which is compiled into fast formatting code.
 class compiled_string {};
@ -196,7 +118,8 @@ template <typename Char> struct code_unit {
  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    return write<Char>(out, value);
+    *out++ = value;
    return out;
  }
 };
@ -220,7 +143,12 @@ template <typename Char, typename T, int N> struct field {
  template <typename OutputIt, typename... Args>
  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    return write<Char>(out, get_arg_checked<T, N>(args...));
+    const T& arg = get_arg_checked<T, N>(args...);
    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
      auto s = basic_string_view<Char>(arg);
      return copy_str<Char>(s.begin(), s.end(), out);
    }
    return write<Char>(out, arg);
  }
 };
@ -331,39 +259,35 @@ template <typename T, typename Char> struct parse_specs_result {
  int next_arg_id;
 };
-constexpr int manual_indexing_id = -1;
+enum { manual_indexing_id = -1 };
 template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                  size_t pos, int next_arg_id) {
  str.remove_prefix(pos);
-  auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
+  auto ctx =
-                                         next_arg_id);
+      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
  auto f = formatter<T, Char>();
  auto end = f.parse(ctx);
-  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
 }
 template <typename Char> struct arg_id_handler {
  arg_ref<Char> arg_id;
-  constexpr int operator()() {
+  constexpr int on_auto() {
    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
    return 0;
  }
-  constexpr int operator()(int id) {
+  constexpr int on_index(int id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }
-  constexpr int operator()(basic_string_view<Char> id) {
+  constexpr int on_name(basic_string_view<Char> id) {
    arg_id = arg_ref<Char>(id);
    return 0;
  }
  constexpr void on_error(const char* message) {
    FMT_THROW(format_error(message));
  }
 };
 template <typename Char> struct parse_arg_id_result {
@ -397,13 +321,20 @@ constexpr auto parse_replacement_field_then_tail(S format_str) {
    return parse_tail<Args, END_POS + 1, NEXT_ID>(
        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
        format_str);
-  } else if constexpr (c == ':') {
+  } else if constexpr (c != ':') {
    FMT_THROW(format_error("expected ':'"));
  } else {
    constexpr auto result = parse_specs<typename field_type<T>::type>(
        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
-    return parse_tail<Args, result.end, result.next_arg_id>(
+    if constexpr (result.end >= str.size() || str[result.end] != '}') {
-        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+      FMT_THROW(format_error("expected '}'"));
-            result.fmt},
+      return 0;
-        format_str);
+    } else {
      return parse_tail<Args, result.end + 1, result.next_arg_id>(
          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
              result.fmt},
          format_str);
    }
  }
 }
@ -445,20 +376,18 @@ constexpr auto compile_format_string(S format_str) {
      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
        constexpr auto arg_index =
            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
-        if constexpr (arg_index != invalid_arg_index) {
+        if constexpr (arg_index >= 0) {
          constexpr auto next_id =
              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
          return parse_replacement_field_then_tail<
              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
              arg_index, next_id>(format_str);
-        } else {
+        } else if constexpr (c == '}') {
-          if constexpr (c == '}') {
+          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-            return parse_tail<Args, arg_id_end_pos + 1, ID>(
+              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
-                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+              format_str);
-                format_str);
+        } else if constexpr (c == ':') {
-          } else if constexpr (c == ':') {
+          return unknown_format();  // no type info for specs parsing
            return unknown_format();  // no type info for specs parsing
          }
        }
      }
    }
@ -494,7 +423,7 @@ constexpr auto compile(S format_str) {
 #endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
@ -561,14 +490,16 @@ template <typename OutputIt, typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
                                         const S& format_str, Args&&... args) {
-  auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
+  using traits = detail::fixed_buffer_traits;
-                           format_str, std::forward<Args>(args)...);
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  return {it.base(), it.count()};
+  format_to(std::back_inserter(buf), format_str, std::forward<Args>(args)...);
  return {buf.out(), buf.count()};
 }
 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-size_t formatted_size(const S& format_str, const Args&... args) {
+FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
                                      const Args&... args) {
  return fmt::format_to(detail::counting_iterator(), format_str, args...)
      .count();
 }
@ -597,7 +528,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
 }  // namespace literals
 #endif
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_COMPILE_H_
--- a/dep/fmt/include/fmt/core.h
+++ b/dep/fmt/include/fmt/core.h
--- a/dep/fmt/include/fmt/format-inl.h
+++ b/dep/fmt/include/fmt/format-inl.h
@ -9,13 +9,9 @@
 #define FMT_FORMAT_INL_H_
 #include <algorithm>
 #include <cctype>
 #include <cerrno>  // errno
 #include <climits>
 #include <cmath>
 #include <cstdarg>
 #include <cstring>  // std::memmove
 #include <cwchar>
 #include <exception>
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
@ -115,16 +111,43 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
  return '.';
 }
 #endif
 FMT_FUNC auto write_loc(appender out, loc_value value,
                        const format_specs<>& specs, locale_ref loc) -> bool {
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
  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 facet(locale).put(out, value, specs);
 #endif
  return false;
 }
 }  // namespace detail
-#if !FMT_MSC_VERSION
+template <typename Locale> typename Locale::id format_facet<Locale>::id;
-FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
+
 #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());
 }
 template <>
 FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
    appender out, loc_value val, const format_specs<>& specs) const -> bool {
  return val.visit(
      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
 }
 #endif
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
+FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt,
                                         format_args args) {
  auto ec = std::error_code(error_code, std::generic_category());
-  return std::system_error(ec, vformat(format_str, args));
+  return std::system_error(ec, vformat(fmt, args));
 }
 namespace detail {
@ -143,58 +166,8 @@ FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
  return (n >> r) | (n << (64 - r));
 }
 // Computes 128-bit result of multiplication of two 64-bit unsigned integers.
 inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
 #if FMT_USE_INT128
  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
 #elif defined(_MSC_VER) && defined(_M_X64)
  auto result = uint128_fallback();
  result.lo_ = _umul128(x, y, &result.hi_);
  return result;
 #else
  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
  uint64_t a = x >> 32;
  uint64_t b = x & mask;
  uint64_t c = y >> 32;
  uint64_t d = y & mask;
  uint64_t ac = a * c;
  uint64_t bc = b * c;
  uint64_t ad = a * d;
  uint64_t bd = b * d;
  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
          (intermediate << 32) + (bd & mask)};
 #endif
 }
 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
 namespace dragonbox {
 // Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
 inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
 #if FMT_USE_INT128
  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
  return static_cast<uint64_t>(p >> 64);
 #elif defined(_MSC_VER) && defined(_M_X64)
  return __umulh(x, y);
 #else
  return umul128(x, y).high();
 #endif
 }
 // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
 inline uint128_fallback umul192_upper128(uint64_t x,
                                         uint128_fallback y) noexcept {
  uint128_fallback r = umul128(x, y.high());
  r += umul128_upper64(x, y.low());
  return r;
 }
 // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
 inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
@ -216,25 +189,13 @@ inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
  return x * y;
 }
 // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
 // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
 inline int floor_log10_pow2(int e) noexcept {
  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
  return (e * 315653) >> 20;
 }
 // Various fast log computations.
 inline int floor_log2_pow10(int e) noexcept {
  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
  return (e * 1741647) >> 19;
 }
 inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
  FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
  return (e * 631305 - 261663) >> 21;
 }
-static constexpr struct {
+FMT_INLINE_VARIABLE constexpr struct {
  uint32_t divisor;
  int shift_amount;
 } div_small_pow10_infos[] = {{10, 16}, {100, 16}};
@ -288,7 +249,7 @@ inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
 }
 // Various subroutines using pow10 cache
-template <class T> struct cache_accessor;
+template <typename T> struct cache_accessor;
 template <> struct cache_accessor<float> {
  using carrier_uint = float_info<float>::carrier_uint;
@ -1009,8 +970,23 @@ template <> struct cache_accessor<double> {
      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
      {0xc5a05277621be293, 0xc7098b7305241886},
-      { 0xf70867153aa2db38,
+      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
-        0xb8cbee4fc66d1ea8 }
+      {0x9a65406d44a5c903, 0x737f74f1dc043329},
      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
      {0xbc789925624c5fe0, 0xb67d16413d132073},
      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
      { 0xdb68c2ca82ed2a05,
        0xa67398db9f6820e2 }
 #else
      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@ -1034,8 +1010,8 @@ template <> struct cache_accessor<double> {
      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
-      { 0x95527a5202df0ccb,
+      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
-        0x0f37801e0c43ebc9 }
+      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
 #endif
    };
@ -1138,8 +1114,12 @@ template <> struct cache_accessor<double> {
  }
 };
 FMT_FUNC uint128_fallback get_cached_power(int k) noexcept {
  return cache_accessor<double>::get_cached_power(k);
 }
 // Various integer checks
-template <class T>
+template <typename T>
 bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
  const int case_shorter_interval_left_endpoint_lower_threshold = 2;
  const int case_shorter_interval_left_endpoint_upper_threshold = 3;
@ -1148,12 +1128,12 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
 }
 // Remove trailing zeros from n and return the number of zeros removed (float)
-FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
+FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
  FMT_ASSERT(n != 0, "");
-  const uint32_t mod_inv_5 = 0xcccccccd;
+  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
-  const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+  constexpr uint32_t mod_inv_5 = 0xcccccccd;
  constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
  int s = 0;
  while (true) {
    auto q = rotr(n * mod_inv_25, 2);
    if (q > max_value<uint32_t>() / 100) break;
@ -1165,7 +1145,6 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
    n = q;
    s |= 1;
  }
  return s;
 }
@ -1179,32 +1158,17 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
  // Is n is divisible by 10^8?
  if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
-    // If yes, work with the quotient.
+    // If yes, work with the quotient...
    auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
-
+    // ... and use the 32 bit variant of the function
-    const uint32_t mod_inv_5 = 0xcccccccd;
+    int s = remove_trailing_zeros(n32, 8);
    const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
    int s = 8;
    while (true) {
      auto q = rotr(n32 * mod_inv_25, 2);
      if (q > max_value<uint32_t>() / 100) break;
      n32 = q;
      s += 2;
    }
    auto q = rotr(n32 * mod_inv_5, 1);
    if (q <= max_value<uint32_t>() / 10) {
      n32 = q;
      s |= 1;
    }
    n = n32;
    return s;
  }
  // If n is not divisible by 10^8, work with n itself.
-  const uint64_t mod_inv_5 = 0xcccccccccccccccd;
+  constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
-  const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // = mod_inv_5 * mod_inv_5
  int s = 0;
  while (true) {
@ -1223,7 +1187,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 }
 // The main algorithm for shorter interval case
-template <class T>
+template <typename T>
 FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
  decimal_fp<T> ret_value;
  // Compute k and beta
@ -1337,7 +1301,7 @@ template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
  if (r < deltai) {
    // Exclude the right endpoint if necessary.
-    if (r == 0 && z_mul.is_integer && !include_right_endpoint) {
+    if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
      --ret_value.significand;
      r = float_info<T>::big_divisor;
      goto small_divisor_case_label;
@ -1346,26 +1310,11 @@ template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
    goto small_divisor_case_label;
  } else {
    // r == deltai; compare fractional parts.
-    const carrier_uint two_fl = two_fc - 1;
+    const typename cache_accessor<T>::compute_mul_parity_result x_mul =
        cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
-    if (!include_left_endpoint ||
+    if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
-        exponent < float_info<T>::case_fc_pm_half_lower_threshold ||
+      goto small_divisor_case_label;
        exponent > float_info<T>::divisibility_check_by_5_threshold) {
      // If the left endpoint is not included, the condition for
      // success is z^(f) < delta^(f) (odd parity).
      // Otherwise, the inequalities on exponent ensure that
      // x is not an integer, so if z^(f) >= delta^(f) (even parity), we in fact
      // have strict inequality.
      if (!cache_accessor<T>::compute_mul_parity(two_fl, cache, beta).parity) {
        goto small_divisor_case_label;
      }
    } else {
      const typename cache_accessor<T>::compute_mul_parity_result x_mul =
          cache_accessor<T>::compute_mul_parity(two_fl, cache, beta);
      if (!x_mul.parity && !x_mul.is_integer) {
        goto small_divisor_case_label;
      }
    }
  }
  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
@ -1404,22 +1353,11 @@ small_divisor_case_label:
  // or equivalently, when y is an integer.
  if (y_mul.parity != approx_y_parity)
    --ret_value.significand;
-  else if (y_mul.is_integer && ret_value.significand % 2 != 0)
+  else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
    --ret_value.significand;
  return ret_value;
 }
 }  // namespace dragonbox
 #ifdef _MSC_VER
 FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
    -> int {
  auto args = va_list();
  va_start(args, fmt);
  int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
  va_end(args);
  return result;
 }
 #endif
 }  // namespace detail
 template <> struct formatter<detail::bigint> {
@ -1428,9 +1366,8 @@ template <> struct formatter<detail::bigint> {
    return ctx.begin();
  }
-  template <typename FormatContext>
+  auto format(const detail::bigint& n, format_context& ctx) const
-  auto format(const detail::bigint& n, FormatContext& ctx) const ->
+      -> format_context::iterator {
      typename FormatContext::iterator {
    auto out = ctx.out();
    bool first = true;
    for (auto i = n.bigits_.size(); i > 0; --i) {
@ -1488,53 +1425,45 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
  return to_string(buffer);
 }
 #ifdef _WIN32
 namespace detail {
 #ifndef _WIN32
 FMT_FUNC bool write_console(std::FILE*, string_view) { return false; }
 #else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
    void*, const void*, dword, dword*, void*);
 }  // namespace detail
 #endif
-namespace detail {
+FMT_FUNC bool write_console(std::FILE* f, string_view text) {
 FMT_FUNC void print(std::FILE* f, string_view text) {
 #ifdef _WIN32
  auto fd = _fileno(f);
-  if (_isatty(fd)) {
+  if (!_isatty(fd)) return false;
-    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
+  auto u16 = utf8_to_utf16(text);
-    auto written = detail::dword();
+  auto written = dword();
-    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
+  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
-                              u16.c_str(), static_cast<uint32_t>(u16.size()),
+                       static_cast<uint32_t>(u16.size()), &written, nullptr) != 0;
                              &written, nullptr)) {
      return;
    }
    // Fallback to fwrite on failure. It can happen if the output has been
    // redirected to NUL.
  }
 #endif
  detail::fwrite_fully(text.data(), 1, text.size(), f);
 }
 }  // namespace detail
 FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
  memory_buffer buffer;
  detail::vformat_to(buffer, format_str, args);
  detail::print(f, {buffer.data(), buffer.size()});
 }
 #ifdef _WIN32
 // Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
+FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
-                                      format_args args) {
+  auto buffer = memory_buffer();
-  memory_buffer buffer;
+  detail::vformat_to(buffer, fmt,
  detail::vformat_to(buffer, format_str,
                     basic_format_args<buffer_context<char>>(args));
  fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 #endif
-FMT_FUNC void vprint(string_view format_str, format_args args) {
+FMT_FUNC void print(std::FILE* f, string_view text) {
-  vprint(stdout, format_str, args);
+  if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f);
 }
 }  // namespace detail
 FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, fmt, args);
  detail::print(f, {buffer.data(), buffer.size()});
 }
 FMT_FUNC void vprint(string_view fmt, format_args args) {
  vprint(stdout, fmt, args);
 }
 namespace detail {
--- a/dep/fmt/include/fmt/format.h
+++ b/dep/fmt/include/fmt/format.h
--- a/dep/fmt/include/fmt/os.h
+++ b/dep/fmt/include/fmt/os.h
@ -71,7 +71,7 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 /**
  \rst
@ -120,51 +120,13 @@ template <typename Char> class basic_cstring_view {
 using cstring_view = basic_cstring_view<char>;
 using wcstring_view = basic_cstring_view<wchar_t>;
 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 <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(out, ec.category().name(),
                              basic_format_specs<Char>());
    out = detail::write<Char>(out, Char(':'));
    out = detail::write<Char>(out, ec.value());
    return out;
  }
 };
 #ifdef _WIN32
 FMT_API const std::error_category& system_category() noexcept;
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 // A converter from UTF-16 to UTF-8.
 // It is only provided for Windows since other systems support UTF-8 natively.
 class utf16_to_utf8 {
 private:
  memory_buffer buffer_;
 public:
  utf16_to_utf8() {}
  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
  operator string_view() const { return string_view(&buffer_[0], size()); }
  size_t size() const { return buffer_.size() - 1; }
  const char* c_str() const { return &buffer_[0]; }
  std::string str() const { return std::string(&buffer_[0], size()); }
  // Performs conversion returning a system error code instead of
  // throwing exception on conversion error. This method may still throw
  // in case of memory allocation error.
  FMT_API int convert(basic_string_view<wchar_t> s);
 };
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
                                  const char* message) noexcept;
-FMT_END_DETAIL_NAMESPACE
+}
 FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
                                         format_args args);
@ -355,12 +317,18 @@ class FMT_API file {
  // Creates a buffered_file object associated with this file and detaches
  // this file object from the file.
  buffered_file fdopen(const char* mode);
 #  if defined(_WIN32) && !defined(__MINGW32__)
  // Opens a file and constructs a file object representing this file by
  // wcstring_view filename. Windows only.
  static file open_windows_file(wcstring_view path, int oflag);
 #  endif
 };
 // Returns the memory page size.
 long getpagesize();
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 struct buffer_size {
  buffer_size() = default;
@ -397,56 +365,61 @@ struct ostream_params {
 #  endif
 };
-FMT_END_DETAIL_NAMESPACE
+class file_buffer final : public buffer<char> {
  file file_;
  FMT_API void grow(size_t) override;
 public:
  FMT_API file_buffer(cstring_view path, const ostream_params& params);
  FMT_API file_buffer(file_buffer&& other);
  FMT_API ~file_buffer();
  void flush() {
    if (size() == 0) return;
    file_.write(data(), size() * sizeof(data()[0]));
    clear();
  }
  void close() {
    flush();
    file_.close();
  }
 };
 }  // namespace detail
 // Added {} below to work around default constructor error known to
 // occur in Xcode versions 7.2.1 and 8.2.1.
 constexpr detail::buffer_size buffer_size{};
 /** A fast output stream which is not thread-safe. */
-class FMT_API ostream final : private detail::buffer<char> {
+class FMT_API ostream {
 private:
-  file file_;
+  FMT_MSC_WARNING(suppress : 4251)
-
+  detail::file_buffer buffer_;
  void grow(size_t) override;
  ostream(cstring_view path, const detail::ostream_params& params)
-      : file_(path, params.oflag) {
+      : buffer_(path, params) {}
    set(new char[params.buffer_size], params.buffer_size);
  }
 public:
-  ostream(ostream&& other)
+  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
        file_(std::move(other.file_)) {
    other.clear();
    other.set(nullptr, 0);
  }
  ~ostream() {
    flush();
    delete[] data();
  }
-  void flush() {
+  ~ostream();
-    if (size() == 0) return;
+
-    file_.write(data(), size());
+  void flush() { buffer_.flush(); }
    clear();
  }
  template <typename... T>
  friend ostream output_file(cstring_view path, T... params);
-  void close() {
+  void close() { buffer_.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(detail::buffer_appender<char>(*this), fmt,
+    vformat_to(detail::buffer_appender<char>(buffer_), fmt,
               fmt::make_format_args(args...));
  }
 };
@ -472,7 +445,7 @@ inline ostream output_file(cstring_view path, T... params) {
 }
 #endif  // FMT_USE_FCNTL
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_OS_H_
--- a/dep/fmt/include/fmt/ostream.h
+++ b/dep/fmt/include/fmt/ostream.h
@ -8,86 +8,65 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
-#include <fstream>
+#include <fstream>  // std::filebuf
-#include <ostream>
+
 #if defined(_WIN32) && defined(__GLIBCXX__)
 #  include <ext/stdio_filebuf.h>
 #  include <ext/stdio_sync_filebuf.h>
 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
 #  include <__std_stream>
 #endif
 #include "format.h"
 FMT_BEGIN_NAMESPACE
 template <typename OutputIt, typename Char> class basic_printf_context;
 namespace detail {
 // Checks if T has a user-defined operator<<.
 template <typename T, typename Char, typename Enable = void>
 class is_streamable {
 private:
  template <typename U>
  static auto test(int)
      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
                              << std::declval<U>()) != 0>;
  template <typename> static auto test(...) -> std::false_type;
  using result = decltype(test<T>(0));
 public:
  is_streamable() = default;
  static const bool value = result::value;
 };
 // Formatting of built-in types and arrays is intentionally disabled because
 // it's handled by standard (non-ostream) formatters.
 template <typename T, typename Char>
 struct is_streamable<
    T, Char,
    enable_if_t<
        std::is_arithmetic<T>::value || std::is_array<T>::value ||
        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
        std::is_same<T, std_string_view<Char>>::value ||
        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
    : std::false_type {};
 template <typename Char> FILE* get_file(std::basic_filebuf<Char>&) {
  return nullptr;
 }
 struct dummy_filebuf {
  FILE* _Myfile;
 };
 template <typename T, typename U = int> struct ms_filebuf {
  using type = dummy_filebuf;
 };
 template <typename T> struct ms_filebuf<T, decltype(T::_Myfile, 0)> {
  using type = T;
 };
 using filebuf_type = ms_filebuf<std::filebuf>::type;
 FILE* get_file(filebuf_type& buf);
 // Generate a unique explicit instantion in every translation unit using a tag
 // type in an anonymous namespace.
 namespace {
-struct filebuf_access_tag {};
+struct file_access_tag {};
 }  // namespace
-template <typename Tag, typename FileMemberPtr, FileMemberPtr file>
+template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
-class filebuf_access {
+class file_access {
-  friend FILE* get_file(filebuf_type& buf) { return buf.*file; }
+  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };
 template class filebuf_access<filebuf_access_tag,
                              decltype(&filebuf_type::_Myfile),
                              &filebuf_type::_Myfile>;
-inline bool write(std::filebuf& buf, fmt::string_view data) {
+#if FMT_MSC_VERSION
-  FILE* f = get_file(buf);
+template class file_access<file_access_tag, std::filebuf,
-  if (!f) return false;
+                           &std::filebuf::_Myfile>;
-  print(f, data);
+auto get_file(std::filebuf&) -> FILE*;
-  return true;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
 template class file_access<file_access_tag, std::__stdoutbuf<char>,
                           &std::__stdoutbuf<char>::__file_>;
 auto get_file(std::__stdoutbuf<char>&) -> FILE*;
 #endif
 inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
 #if FMT_MSC_VERSION
  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
    if (FILE* f = get_file(*buf)) return write_console(f, data);
 #elif defined(_WIN32) && defined(__GLIBCXX__)
  auto* rdbuf = os.rdbuf();
  FILE* c_file;
  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
    c_file = sfbuf->file();
  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
    c_file = fbuf->file();
  else
    return false;
  if (c_file) return write_console(c_file, data);
 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
    if (FILE* f = get_file(*buf)) return write_console(f, data);
 #else
  ignore_unused(os, data);
 #endif
  return false;
 }
-inline bool write(std::wfilebuf&, fmt::basic_string_view<wchar_t>) {
+inline bool write_ostream_unicode(std::wostream&,
                                  fmt::basic_string_view<wchar_t>) {
  return false;
 }
@ -95,10 +74,6 @@ inline bool write(std::wfilebuf&, fmt::basic_string_view<wchar_t>) {
 // 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) {
  if (const_check(FMT_MSC_VERSION)) {
    auto filebuf = dynamic_cast<std::basic_filebuf<Char>*>(os.rdbuf());
    if (filebuf && write(*filebuf, {buf.data(), buf.size()})) return;
  }
  const Char* buf_data = buf.data();
  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
  unsigned_streamsize size = buf.size();
@ -130,11 +105,13 @@ template <typename T> struct streamed_view { const T& value; };
 // Formats an object of type T that has an overloaded ostream operator<<.
 template <typename Char>
 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
  void set_debug_format() = delete;
  template <typename T, typename OutputIt>
  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
      -> OutputIt {
    auto buffer = basic_memory_buffer<Char>();
-    format_value(buffer, value, ctx.locale());
+    detail::format_value(buffer, value, ctx.locale());
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
@ -142,12 +119,13 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
 using ostream_formatter = basic_ostream_formatter<char>;
-template <typename T>
+template <typename T, typename Char>
-struct formatter<detail::streamed_view<T>> : ostream_formatter {
+struct formatter<detail::streamed_view<T>, Char>
    : basic_ostream_formatter<Char> {
  template <typename OutputIt>
  auto format(detail::streamed_view<T> view,
-              basic_format_context<OutputIt, char>& ctx) const -> OutputIt {
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
-    return ostream_formatter::format(view.value, ctx);
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
  }
 };
@ -168,21 +146,22 @@ auto streamed(const T& value) -> detail::streamed_view<T> {
 namespace detail {
-// Formats an object of type T that has an overloaded ostream operator<<.
+inline void vprint_directly(std::ostream& os, string_view format_str,
-template <typename T, typename Char>
+                            format_args args) {
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+  auto buffer = memory_buffer();
-    : basic_ostream_formatter<Char> {
+  detail::vformat_to(buffer, format_str, args);
-  using basic_ostream_formatter<Char>::format;
+  detail::write_buffer(os, buffer);
-};
+}
 }  // namespace detail
-FMT_MODULE_EXPORT template <typename Char>
+FMT_EXPORT template <typename Char>
 void vprint(std::basic_ostream<Char>& os,
            basic_string_view<type_identity_t<Char>> format_str,
            basic_format_args<buffer_context<type_identity_t<Char>>> 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::write_buffer(os, buffer);
 }
@ -195,12 +174,16 @@ void vprint(std::basic_ostream<Char>& os,
    fmt::print(cerr, "Don't {}!", "panic");
  \endrst
 */
-FMT_MODULE_EXPORT template <typename... T>
+FMT_EXPORT template <typename... T>
 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  vprint(os, fmt, fmt::make_format_args(args...));
+  const auto& vargs = fmt::make_format_args(args...);
  if (detail::is_utf8())
    vprint(os, fmt, vargs);
  else
    detail::vprint_directly(os, fmt, vargs);
 }
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename... Args>
 void print(std::wostream& os,
           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
@ -208,6 +191,19 @@ void print(std::wostream& os,
  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 }
 FMT_EXPORT template <typename... T>
 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/dep/fmt/include/fmt/printf.h
+++ b/dep/fmt/include/fmt/printf.h
@ -14,24 +14,18 @@
 #include "format.h"
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 template <typename T> struct printf_formatter { printf_formatter() = delete; };
-template <typename Char>
+template <typename Char> class basic_printf_context {
 class basic_printf_parse_context : public basic_format_parse_context<Char> {
  using basic_format_parse_context<Char>::basic_format_parse_context;
 };
 template <typename OutputIt, typename Char> class basic_printf_context {
 private:
-  OutputIt out_;
+  detail::buffer_appender<Char> out_;
  basic_format_args<basic_printf_context> args_;
 public:
  using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_format_parse_context<Char>;
  using parse_context_type = basic_printf_parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;
  /**
@ -40,68 +34,68 @@ template <typename OutputIt, typename Char> class basic_printf_context {
    stored in the context object so make sure they have appropriate lifetimes.
    \endrst
   */
-  basic_printf_context(OutputIt out,
+  basic_printf_context(detail::buffer_appender<Char> out,
                       basic_format_args<basic_printf_context> args)
      : out_(out), args_(args) {}
-  OutputIt out() { return out_; }
+  auto out() -> detail::buffer_appender<Char> { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
+  void advance_to(detail::buffer_appender<Char>) {}
-  detail::locale_ref locale() { return {}; }
+  auto locale() -> detail::locale_ref { return {}; }
-  format_arg arg(int id) const { return args_.get(id); }
+  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
    return args_.get(id);
  }
  FMT_CONSTEXPR void on_error(const char* message) {
    detail::error_handler().on_error(message);
  }
 };
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned> struct int_checker {
-  template <typename T> static bool fits_in_int(T value) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
    unsigned max = max_value<int>();
    return value <= max;
  }
-  static bool fits_in_int(bool) { return true; }
+  static auto fits_in_int(bool) -> bool { return true; }
 };
 template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
-  static bool fits_in_int(int) { return true; }
+  static auto fits_in_int(int) -> bool { return true; }
 };
-class printf_precision_handler {
+struct printf_precision_handler {
 public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
+  auto operator()(T value) -> int {
    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
+      throw_format_error("number is too big");
    return (std::max)(static_cast<int>(value), 0);
  }
  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  int operator()(T) {
+  auto operator()(T) -> int {
-    FMT_THROW(format_error("precision is not integer"));
+    throw_format_error("precision is not integer");
    return 0;
  }
 };
 // An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int {
+struct is_zero_int {
 public:
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
+  auto operator()(T value) -> bool {
    return value == 0;
  }
  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
+  auto operator()(T) -> bool {
    return false;
  }
 };
@ -132,22 +126,23 @@ template <typename T, typename Context> class arg_converter {
    if (const_check(sizeof(target_type) <= sizeof(int))) {
      // Extra casts are used to silence warnings.
      if (is_signed) {
-        arg_ = detail::make_arg<Context>(
+        auto n = static_cast<int>(static_cast<target_type>(value));
-            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;
-        arg_ = detail::make_arg<Context>(
+        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+        arg_ = detail::make_arg<Context>(n);
      }
    } 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.
-        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
+        auto n = static_cast<long long>(value);
        arg_ = detail::make_arg<Context>(n);
      } else {
-        arg_ = detail::make_arg<Context>(
+        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+        arg_ = detail::make_arg<Context>(n);
      }
    }
  }
@ -175,8 +170,8 @@ template <typename Context> class char_converter {
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
  void operator()(T value) {
-    arg_ = detail::make_arg<Context>(
+    auto c = static_cast<typename Context::char_type>(value);
-        static_cast<typename Context::char_type>(value));
+    arg_ = detail::make_arg<Context>(c);
  }
  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@ -186,122 +181,131 @@ template <typename Context> class char_converter {
 // An argument visitor that return a pointer to a C string if argument is a
 // string or null otherwise.
 template <typename Char> struct get_cstring {
-  template <typename T> const Char* operator()(T) { return nullptr; }
+  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
-  const Char* operator()(const Char* s) { return s; }
+  auto operator()(const Char* s) -> const Char* { return s; }
 };
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
 template <typename Char> class printf_width_handler {
 private:
-  using format_specs = basic_format_specs<Char>;
+  format_specs<Char>& specs_;
  format_specs& specs_;
 public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(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;
      width = 0 - width;
    }
    unsigned int_max = max_value<int>();
-    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    if (width > int_max) throw_format_error("number is too big");
    return static_cast<unsigned>(width);
  }
  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  unsigned operator()(T) {
+  auto operator()(T) -> unsigned {
-    FMT_THROW(format_error("width is not integer"));
+    throw_format_error("width is not integer");
    return 0;
  }
 };
 // Workaround for a bug with the XL compiler when initializing
 // printf_arg_formatter's base class.
 template <typename Char>
 auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
    -> arg_formatter<Char> {
  return {iter, s, locale_ref()};
 }
 // The ``printf`` argument formatter.
-template <typename OutputIt, typename Char>
+template <typename Char>
 class printf_arg_formatter : public arg_formatter<Char> {
 private:
  using base = arg_formatter<Char>;
-  using context_type = basic_printf_context<OutputIt, Char>;
+  using context_type = basic_printf_context<Char>;
  using format_specs = basic_format_specs<Char>;
  context_type& context_;
-  OutputIt write_null_pointer(bool is_string = false) {
+  void write_null_pointer(bool is_string = false) {
    auto s = this->specs;
    s.type = presentation_type::none;
-    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
  }
 public:
-  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
+  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
-      : base{iter, s, locale_ref()}, context_(ctx) {}
+                       context_type& ctx)
      : base(make_arg_formatter(iter, s)), context_(ctx) {}
-  OutputIt operator()(monostate value) { return base::operator()(value); }
+  void operator()(monostate value) { base::operator()(value); }
  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  OutputIt operator()(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) {
+    if (!std::is_same<T, Char>::value) {
-      format_specs fmt_specs = this->specs;
+      base::operator()(value);
-      if (fmt_specs.type != presentation_type::none &&
+      return;
          fmt_specs.type != presentation_type::chr) {
        return (*this)(static_cast<int>(value));
      }
      fmt_specs.sign = sign::none;
      fmt_specs.alt = false;
      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
      // align::numeric needs to be overwritten here since the '0' flag is
      // ignored for non-numeric types
      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
        fmt_specs.align = align::right;
      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
    }
-    return base::operator()(value);
+    format_specs<Char> fmt_specs = this->specs;
    if (fmt_specs.type != presentation_type::none &&
        fmt_specs.type != presentation_type::chr) {
      return (*this)(static_cast<int>(value));
    }
    fmt_specs.sign = sign::none;
    fmt_specs.alt = false;
    fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
    // align::numeric needs to be overwritten here since the '0' flag is
    // ignored for non-numeric types
    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
      fmt_specs.align = align::right;
    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
  }
  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  OutputIt operator()(T value) {
+  void operator()(T value) {
-    return base::operator()(value);
+    base::operator()(value);
  }
  /** Formats a null-terminated C string. */
-  OutputIt operator()(const char* value) {
+  void operator()(const char* value) {
-    if (value) return base::operator()(value);
+    if (value)
-    return write_null_pointer(this->specs.type != presentation_type::pointer);
+      base::operator()(value);
    else
      write_null_pointer(this->specs.type != presentation_type::pointer);
  }
  /** Formats a null-terminated wide C string. */
-  OutputIt operator()(const wchar_t* value) {
+  void operator()(const wchar_t* value) {
-    if (value) return base::operator()(value);
+    if (value)
-    return write_null_pointer(this->specs.type != presentation_type::pointer);
+      base::operator()(value);
    else
      write_null_pointer(this->specs.type != presentation_type::pointer);
  }
-  OutputIt operator()(basic_string_view<Char> value) {
+  void operator()(basic_string_view<Char> value) { base::operator()(value); }
    return base::operator()(value);
  }
  /** Formats a pointer. */
-  OutputIt operator()(const void* value) {
+  void operator()(const void* value) {
-    return value ? base::operator()(value) : write_null_pointer();
+    if (value)
      base::operator()(value);
    else
      write_null_pointer();
  }
  /** Formats an argument of a custom (user-defined) type. */
-  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx =
+    auto parse_ctx = basic_format_parse_context<Char>({});
        basic_printf_parse_context<Char>(basic_string_view<Char>());
    handle.format(parse_ctx, context_);
    return this->out;
  }
 };
 template <typename Char>
-void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
                 const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
    case '-':
@ -314,9 +318,7 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
      specs.fill[0] = '0';
      break;
    case ' ':
-      if (specs.sign != sign::plus) {
+      if (specs.sign != sign::plus) specs.sign = sign::space;
        specs.sign = sign::space;
      }
      break;
    case '#':
      specs.alt = true;
@ -328,8 +330,8 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
 }
 template <typename Char, typename GetArg>
-int parse_header(const Char*& it, const Char* end,
+auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
-                 basic_format_specs<Char>& specs, GetArg get_arg) {
+                  GetArg get_arg) -> int {
  int arg_index = -1;
  Char c = *it;
  if (c >= '0' && c <= '9') {
@ -344,7 +346,7 @@ int parse_header(const Char*& it, const Char* end,
      if (value != 0) {
        // Nonzero value means that we parsed width and don't need to
        // parse it or flags again, so return now.
-        if (value == -1) FMT_THROW(format_error("number is too big"));
+        if (value == -1) throw_format_error("number is too big");
        specs.width = value;
        return arg_index;
      }
@ -355,7 +357,7 @@ int parse_header(const Char*& it, const Char* end,
  if (it != end) {
    if (*it >= '0' && *it <= '9') {
      specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
+      if (specs.width == -1) throw_format_error("number is too big");
    } else if (*it == '*') {
      ++it;
      specs.width = static_cast<int>(visit_format_arg(
@ -365,13 +367,53 @@ int parse_header(const Char*& it, const Char* end,
  return arg_index;
 }
 inline auto parse_printf_presentation_type(char c, type t)
    -> presentation_type {
  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':
    return in(t, integral_set) ? pt::hex_lower : pt::none;
  case 'X':
    return in(t, integral_set) ? pt::hex_upper : pt::none;
  case 'a':
    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
  case 'A':
    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
  case 'e':
    return in(t, float_set) ? pt::exp_lower : pt::none;
  case 'E':
    return in(t, float_set) ? pt::exp_upper : pt::none;
  case 'f':
    return in(t, float_set) ? pt::fixed_lower : pt::none;
  case 'F':
    return in(t, float_set) ? pt::fixed_upper : pt::none;
  case 'g':
    return in(t, float_set) ? pt::general_lower : pt::none;
  case 'G':
    return in(t, float_set) ? pt::general_upper : 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;
  }
 }
 template <typename Char, typename Context>
 void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
             basic_format_args<Context> args) {
-  using OutputIt = buffer_appender<Char>;
+  using iterator = buffer_appender<Char>;
-  auto out = OutputIt(buf);
+  auto out = iterator(buf);
-  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = basic_printf_parse_context<Char>(format);
+  auto parse_ctx = basic_format_parse_context<Char>(format);
  // Returns the argument with specified index or, if arg_index is -1, the next
  // argument.
@ -387,26 +429,24 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
  const Char* end = parse_ctx.end();
  auto it = start;
  while (it != end) {
-    if (!detail::find<false, Char>(it, end, '%', it)) {
+    if (!find<false, Char>(it, end, '%', it)) {
-      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
+      it = end;  // find leaves it == nullptr if it doesn't find '%'.
      break;
    }
    Char c = *it++;
    if (it != end && *it == c) {
-      out = detail::write(
+      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
      start = ++it;
      continue;
    }
-    out = detail::write(out, basic_string_view<Char>(
+    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
                                 start, detail::to_unsigned(it - 1 - start)));
-    basic_format_specs<Char> specs;
+    auto specs = format_specs<Char>();
    specs.align = align::right;
    // Parse argument index, flags and width.
    int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) parse_ctx.on_error("argument not found");
+    if (arg_index == 0) throw_format_error("argument not found");
    // Parse precision.
    if (it != end && *it == '.') {
@ -417,7 +457,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
      } else if (c == '*') {
        ++it;
        specs.precision = static_cast<int>(
-            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+            visit_format_arg(printf_precision_handler(), get_arg(-1)));
      } else {
        specs.precision = 0;
      }
@ -426,20 +466,19 @@ 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 && arg.is_integral()) {
-      specs.fill[0] =
+      // Ignore '0' for non-numeric types or if '-' present.
-          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
+      specs.fill[0] = ' ';
-    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
+    }
-      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
+    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
      auto str = visit_format_arg(get_cstring<Char>(), arg);
      auto str_end = str + specs.precision;
      auto nul = std::find(str, str_end, Char());
-      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+      auto sv = basic_string_view<Char>(
-          basic_string_view<Char>(
+          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-              str, detail::to_unsigned(nul != str_end ? nul - str
+      arg = make_arg<basic_printf_context<Char>>(sv);
                                                      : specs.precision)));
    }
-    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
      specs.alt = false;
    if (specs.fill[0] == '0') {
      if (arg.is_arithmetic() && specs.align != align::left)
        specs.align = align::numeric;
@ -451,7 +490,6 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    // Parse length and convert the argument to the required type.
    c = it != end ? *it++ : 0;
    Char t = it != end ? *it : 0;
    using detail::convert_arg;
    switch (c) {
    case 'h':
      if (t == 'h') {
@ -490,7 +528,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
    }
    // Parse type.
-    if (it == end) FMT_THROW(format_error("invalid format string"));
+    if (it == end) throw_format_error("invalid format string");
    char type = static_cast<char>(*it++);
    if (arg.is_integral()) {
      // Normalize type.
@ -500,32 +538,25 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
        type = 'd';
        break;
      case 'c':
-        visit_format_arg(
+        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
            arg);
        break;
      }
    }
-    specs.type = parse_presentation_type(type);
+    specs.type = parse_printf_presentation_type(type, arg.type());
    if (specs.type == presentation_type::none)
-      parse_ctx.on_error("invalid type specifier");
+      throw_format_error("invalid format specifier");
    start = it;
    // Format argument.
-    out = visit_format_arg(
+    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
  }
-  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
-template <typename Char>
+using printf_context = basic_printf_context<char>;
-using basic_printf_context_t =
+using wprintf_context = basic_printf_context<wchar_t>;
    basic_printf_context<detail::buffer_appender<Char>, Char>;
 using printf_context = basic_printf_context_t<char>;
 using wprintf_context = basic_printf_context_t<wchar_t>;
 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
@ -542,26 +573,21 @@ inline auto make_printf_args(const T&... args)
  return {args...};
 }
-/**
+// DEPRECATED!
  \rst
  Constructs an `~fmt::format_arg_store` object that contains references to
  arguments and can be implicitly converted to `~fmt::wprintf_args`.
  \endrst
 */
 template <typename... T>
 inline auto make_wprintf_args(const T&... args)
    -> format_arg_store<wprintf_context, T...> {
  return {args...};
 }
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
 inline auto vsprintf(
-    const S& fmt,
+    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buffer;
+  auto buf = basic_memory_buffer<Char>();
-  vprintf(buffer, detail::to_string_view(fmt), args);
+  detail::vprintf(buf, fmt, args);
-  return to_string(buffer);
+  return to_string(buf);
 }
 /**
@ -576,20 +602,19 @@ inline auto vsprintf(
 template <typename S, typename... T,
          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
 inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  using context = basic_printf_context_t<Char>;
  return vsprintf(detail::to_string_view(fmt),
-                  fmt::make_format_args<context>(args...));
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
 inline auto vfprintf(
-    std::FILE* f, const S& fmt,
+    std::FILE* f, basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> int {
-  basic_memory_buffer<Char> buffer;
+  auto buf = basic_memory_buffer<Char>();
-  vprintf(buffer, detail::to_string_view(fmt), args);
+  detail::vprintf(buf, fmt, args);
-  size_t size = buffer.size();
+  size_t size = buf.size();
-  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
+  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
             ? -1
             : static_cast<int>(size);
 }
@ -605,17 +630,16 @@ inline auto vfprintf(
 */
 template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  using context = basic_printf_context_t<Char>;
  return vfprintf(f, detail::to_string_view(fmt),
-                  fmt::make_format_args<context>(args...));
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
-inline auto vprintf(
+FMT_DEPRECATED inline auto vprintf(
-    const S& fmt,
+    basic_string_view<Char> fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> int {
-  return vfprintf(stdout, detail::to_string_view(fmt), args);
+  return vfprintf(stdout, fmt, args);
 }
 /**
@ -627,14 +651,17 @@ inline auto vprintf(
    fmt::printf("Elapsed time: %.2f seconds", 1.23);
  \endrst
 */
-template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+template <typename... T>
-inline auto printf(const S& fmt, const T&... args) -> int {
+inline auto printf(string_view fmt, const T&... args) -> int {
-  return vprintf(
+  return vfprintf(stdout, fmt, make_printf_args(args...));
-      detail::to_string_view(fmt),
+}
-      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
+template <typename... T>
 FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
                                  const T&... args) -> int {
  return vfprintf(stdout, fmt, make_wprintf_args(args...));
 }
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_PRINTF_H_
--- a/dep/fmt/include/fmt/ranges.h
+++ b/dep/fmt/include/fmt/ranges.h
@ -22,27 +22,25 @@ FMT_BEGIN_NAMESPACE
 namespace detail {
-template <typename RangeT, typename OutputIterator>
+template <typename Range, typename OutputIt>
-OutputIterator copy(const RangeT& range, OutputIterator out) {
+auto copy(const Range& range, OutputIt out) -> OutputIt {
  for (auto it = range.begin(), end = range.end(); it != end; ++it)
    *out++ = *it;
  return out;
 }
-template <typename OutputIterator>
+template <typename OutputIt>
-OutputIterator copy(const char* str, OutputIterator out) {
+auto copy(const char* str, OutputIt out) -> OutputIt {
  while (*str) *out++ = *str++;
  return out;
 }
-template <typename OutputIterator>
+template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
 OutputIterator copy(char ch, OutputIterator out) {
  *out++ = ch;
  return out;
 }
-template <typename OutputIterator>
+template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
 OutputIterator copy(wchar_t ch, OutputIterator out) {
  *out++ = ch;
  return out;
 }
@ -69,7 +67,7 @@ template <typename T> class is_map {
  template <typename> static void check(...);
 public:
-#ifdef FMT_FORMAT_MAP_AS_LIST
+#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
  static constexpr const bool value = false;
 #else
  static constexpr const bool value =
@ -82,7 +80,7 @@ template <typename T> class is_set {
  template <typename> static void check(...);
 public:
-#ifdef FMT_FORMAT_SET_AS_LIST
+#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
  static constexpr const bool value = false;
 #else
  static constexpr const bool value =
@ -157,8 +155,9 @@ template <typename T>
 struct has_mutable_begin_end<
    T, void_t<decltype(detail::range_begin(std::declval<T>())),
              decltype(detail::range_end(std::declval<T>())),
-              enable_if_t<std::is_copy_constructible<T>::value>>>
+              // the extra int here is because older versions of MSVC don't
-    : std::true_type {};
+              // SFINAE properly unless there are distinct types
              int>> : std::true_type {};
 template <typename T>
 struct is_range_<T, void>
@ -211,41 +210,61 @@ class is_tuple_formattable_ {
  static constexpr const bool value = false;
 };
 template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <std::size_t... I>
+  template <std::size_t... Is>
-  static std::true_type check2(index_sequence<I...>,
+  static std::true_type check2(index_sequence<Is...>,
-                               integer_sequence<bool, (I == I)...>);
+                               integer_sequence<bool, (Is == Is)...>);
  static std::false_type check2(...);
-  template <std::size_t... I>
+  template <std::size_t... Is>
  static decltype(check2(
-      index_sequence<I...>{},
+      index_sequence<Is...>{},
      integer_sequence<
-          bool, (is_formattable<typename std::tuple_element<I, T>::type,
+          bool, (is_formattable<typename std::tuple_element<Is, T>::type,
-                                C>::value)...>{})) check(index_sequence<I...>);
+                                C>::value)...>{})) check(index_sequence<Is...>);
 public:
  static constexpr const bool value =
      decltype(check(tuple_index_sequence<T>{}))::value;
 };
-template <class Tuple, class F, size_t... Is>
+template <typename Tuple, typename F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
+FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
  using std::get;
-  // using free function get<I>(T) now.
+  // Using a free function get<Is>(Tuple) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
-  (void)_;  // blocks warnings
+  ignore_unused(unused);
 }
-template <class T>
+template <typename Tuple, typename F>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
-    T const&) {
+  for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
-  return {};
+           std::forward<Tuple>(t), std::forward<F>(f));
 }
-template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
-  const auto indexes = get_indexes(tup);
+void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+  using std::get;
  const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
  ignore_unused(unused);
 }
 template <typename Tuple1, typename Tuple2, typename F>
 void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
  for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
            std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
            std::forward<F>(f));
 }
 namespace tuple {
 // Workaround a bug in MSVC 2019 (v140).
 template <typename Char, typename... T>
 using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
 using std::get;
 template <typename Tuple, typename Char, std::size_t... Is>
 auto get_formatters(index_sequence<Is...>)
    -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
 }  // namespace tuple
 #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
 // Older MSVC doesn't get the reference type correctly for arrays.
 template <typename R> struct range_reference_type_impl {
@ -269,45 +288,37 @@ using range_reference_type =
 template <typename Range>
 using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
-template <typename Range>
+template <typename Formatter>
-using uncvref_first_type = remove_cvref_t<
+FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
-    decltype(std::declval<range_reference_type<Range>>().first)>;
+    -> decltype(f.set_debug_format(set)) {
-
+  f.set_debug_format(set);
 template <typename Range>
 using uncvref_second_type = remove_cvref_t<
    decltype(std::declval<range_reference_type<Range>>().second)>;
 template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
  *out++ = ',';
  *out++ = ' ';
  return out;
 }
 template <typename Formatter>
 FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
-template <typename Char, typename OutputIt>
+// These are not generic lambdas for compatibility with C++11.
-auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
+template <typename ParseContext> struct parse_empty_specs {
-  return write_escaped_string(out, str);
+  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
-}
+    f.parse(ctx);
    detail::maybe_set_debug_format(f, true);
  }
  ParseContext& ctx;
 };
 template <typename FormatContext> struct format_tuple_element {
  using char_type = typename FormatContext::char_type;
-template <typename Char, typename OutputIt, typename T,
+  template <typename T>
-          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
+  void operator()(const formatter<T, char_type>& f, const T& v) {
-inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
+    if (i > 0)
-  auto sv = std_string_view<Char>(str);
+      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
-  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
+    ctx.advance_to(f.format(v, ctx));
-}
+    ++i;
  }
-template <typename Char, typename OutputIt, typename Arg,
+  int i;
-          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+  FormatContext& ctx;
-OutputIt write_range_entry(OutputIt out, const Arg v) {
+  basic_string_view<char_type> separator;
-  return write_escaped_char(out, v);
+};
 }
 template <
    typename Char, typename OutputIt, typename Arg,
    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
                  !std::is_same<Arg, Char>::value)>
 OutputIt write_range_entry(OutputIt out, const Arg& v) {
  return write<Char>(out, v);
 }
 }  // namespace detail
@ -321,45 +332,58 @@ template <typename T, typename C> struct is_tuple_formattable {
      detail::is_tuple_formattable_<T, C>::value;
 };
-template <typename TupleT, typename Char>
+template <typename Tuple, typename Char>
-struct formatter<TupleT, Char,
+struct formatter<Tuple, Char,
-                 enable_if_t<fmt::is_tuple_like<TupleT>::value &&
+                 enable_if_t<fmt::is_tuple_like<Tuple>::value &&
-                             fmt::is_tuple_formattable<TupleT, Char>::value>> {
+                             fmt::is_tuple_formattable<Tuple, Char>::value>> {
 private:
-  // C++11 generic lambda for format().
+  decltype(detail::tuple::get_formatters<Tuple, Char>(
-  template <typename FormatContext> struct format_each {
+      detail::tuple_index_sequence<Tuple>())) formatters_;
-    template <typename T> void operator()(const T& v) {
+
-      if (i > 0) out = detail::write_delimiter(out);
+  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
-      out = detail::write_range_entry<Char>(out, v);
+  basic_string_view<Char> opening_bracket_ =
-      ++i;
+      detail::string_literal<Char, '('>{};
-    }
+  basic_string_view<Char> closing_bracket_ =
-    int i;
+      detail::string_literal<Char, ')'>{};
    typename FormatContext::iterator& out;
  };
 public:
-  template <typename ParseContext>
+  FMT_CONSTEXPR formatter() {}
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+
-    return ctx.begin();
+  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
    separator_ = sep;
  }
-  template <typename FormatContext = format_context>
+  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
-  auto format(const TupleT& values, FormatContext& ctx) const
+                                  basic_string_view<Char> close) {
    opening_bracket_ = open;
    closing_bracket_ = close;
  }
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    if (it != ctx.end() && *it != '}')
      FMT_THROW(format_error("invalid format specifier"));
    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
    return it;
  }
  template <typename FormatContext>
  auto format(const Tuple& value, FormatContext& ctx) const
      -> decltype(ctx.out()) {
-    auto out = ctx.out();
+    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
-    *out++ = '(';
+    detail::for_each2(
-    detail::for_each(values, format_each<FormatContext>{0, out});
+        formatters_, value,
-    *out++ = ')';
+        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
-    return out;
+    return detail::copy_str<Char>(closing_bracket_, ctx.out());
  }
 };
 template <typename T, typename Char> struct is_range {
  static constexpr const bool value =
      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
      !detail::is_map<T>::value &&
      !std::is_convertible<T, std::basic_string<Char>>::value &&
-      !std::is_constructible<detail::std_string_view<Char>, T>::value;
+      !std::is_convertible<T, detail::std_string_view<Char>>::value;
 };
 namespace detail {
@ -380,126 +404,171 @@ template <typename Context> struct range_mapper {
 };
 template <typename Char, typename Element>
-using range_formatter_type = conditional_t<
+using range_formatter_type =
    is_formattable<Element, Char>::value,
    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
                  std::declval<Element>()))>,
-              Char>,
+              Char>;
    fallback_formatter<Element, Char>>;
 template <typename R>
 using maybe_const_range =
    conditional_t<has_const_begin_end<R>::value, const R, R>;
 // Workaround a bug in MSVC 2015 and earlier.
 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
 template <typename R, typename Char>
 struct is_formattable_delayed
    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
 #endif
 }  // namespace detail
-template <typename R, typename Char>
+template <typename T, typename Char, typename Enable = void>
-struct formatter<
+struct range_formatter;
    R, Char,
    enable_if_t<
        conjunction<fmt::is_range<R, Char>
 // Workaround a bug in MSVC 2017 and earlier.
 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1920
        ,
        disjunction<
          is_formattable<detail::uncvref_type<detail::maybe_const_range<R>>,
                         Char>,
          detail::has_fallback_formatter<
             detail::uncvref_type<detail::maybe_const_range<R>>, Char>
        >
 #endif
        >::value
        >> {
-  using range_type = detail::maybe_const_range<R>;
+template <typename T, typename Char>
-  using formatter_type =
+struct range_formatter<
-      detail::range_formatter_type<Char, detail::uncvref_type<range_type>>;
+    T, Char,
-  formatter_type underlying_;
+    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
-  bool custom_specs_ = false;
+                            is_formattable<T, Char>>::value>> {
 private:
  detail::range_formatter_type<Char, T> underlying_;
  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
  basic_string_view<Char> opening_bracket_ =
      detail::string_literal<Char, '['>{};
  basic_string_view<Char> closing_bracket_ =
      detail::string_literal<Char, ']'>{};
 public:
  FMT_CONSTEXPR range_formatter() {}
  FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
    return underlying_;
  }
  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
    separator_ = sep;
  }
  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
                                  basic_string_view<Char> close) {
    opening_bracket_ = open;
    closing_bracket_ = close;
  }
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it == end || *it == '}') return it;
-    if (*it != ':')
+    if (it != end && *it == 'n') {
-      FMT_THROW(format_error("no top-level range formatters supported"));
+      set_brackets({}, {});
      ++it;
    }
    if (it != end && *it != '}') {
      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
      ++it;
    } else {
      detail::maybe_set_debug_format(underlying_, true);
    }
    custom_specs_ = true;
    ++it;
    ctx.advance_to(it);
    return underlying_.parse(ctx);
  }
  template <typename R, typename FormatContext>
  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
    detail::range_mapper<buffer_context<Char>> mapper;
    auto out = ctx.out();
    out = detail::copy_str<Char>(opening_bracket_, out);
    int i = 0;
    auto it = detail::range_begin(range);
    auto end = detail::range_end(range);
    for (; it != end; ++it) {
      if (i > 0) out = detail::copy_str<Char>(separator_, out);
      ctx.advance_to(out);
      out = underlying_.format(mapper.map(*it), ctx);
      ++i;
    }
    out = detail::copy_str<Char>(closing_bracket_, out);
    return out;
  }
 };
 enum class range_format { disabled, map, set, sequence, string, debug_string };
 namespace detail {
 template <typename T>
 struct range_format_kind_
    : std::integral_constant<range_format,
                             std::is_same<uncvref_type<T>, T>::value
                                 ? range_format::disabled
                             : is_map<T>::value ? range_format::map
                             : is_set<T>::value ? range_format::set
                                                : range_format::sequence> {};
 template <range_format K, typename R, typename Char, typename Enable = void>
 struct range_default_formatter;
 template <range_format K>
 using range_format_constant = std::integral_constant<range_format, K>;
 template <range_format K, typename R, typename Char>
 struct range_default_formatter<
    K, R, Char,
    enable_if_t<(K == range_format::sequence || K == range_format::map ||
                 K == range_format::set)>> {
  using range_type = detail::maybe_const_range<R>;
  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
                             detail::string_literal<Char, '}'>{});
  }
  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
                             detail::string_literal<Char, '}'>{});
    underlying_.underlying().set_brackets({}, {});
    underlying_.underlying().set_separator(
        detail::string_literal<Char, ':', ' '>{});
  }
  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return underlying_.parse(ctx);
  }
  template <typename FormatContext>
  auto format(range_type& range, FormatContext& ctx) const
      -> decltype(ctx.out()) {
-    Char prefix = detail::is_set<R>::value ? '{' : '[';
+    return underlying_.format(range, ctx);
    Char postfix = detail::is_set<R>::value ? '}' : ']';
    detail::range_mapper<buffer_context<Char>> mapper;
    auto out = ctx.out();
    *out++ = prefix;
    int i = 0;
    auto it = detail::range_begin(range);
    auto end = detail::range_end(range);
    for (; it != end; ++it) {
      if (i > 0) out = detail::write_delimiter(out);
      if (custom_specs_) {
        ctx.advance_to(out);
        out = underlying_.format(mapper.map(*it), ctx);
      } else {
        out = detail::write_range_entry<Char>(out, *it);
      }
      ++i;
    }
    *out++ = postfix;
    return out;
  }
 };
 }  // namespace detail
-template <typename T, typename Char>
+template <typename T, typename Char, typename Enable = void>
 struct range_format_kind
    : conditional_t<
          is_range<T, Char>::value, detail::range_format_kind_<T>,
          std::integral_constant<range_format, range_format::disabled>> {};
 template <typename R, typename Char>
 struct formatter<
-    T, Char,
+    R, Char,
-    enable_if_t<conjunction<detail::is_map<T>
+    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
-// Workaround a bug in MSVC 2017 and earlier.
+                                          range_format::disabled>
-#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1920
+// Workaround a bug in MSVC 2015 and earlier.
-        ,
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
-        disjunction<
+                            ,
-          is_formattable<detail::uncvref_first_type<T>, Char>,
+                            detail::is_formattable_delayed<R, Char>
          detail::has_fallback_formatter<detail::uncvref_first_type<T>, Char>
        >,
        disjunction<
          is_formattable<detail::uncvref_second_type<T>, Char>,
          detail::has_fallback_formatter<detail::uncvref_second_type<T>, Char>
        >
 #endif
-    >::value
+                            >::value>>
-    >> {
+    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
-  template <typename ParseContext>
+                                      Char> {
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  template <
      typename FormatContext, typename U,
      FMT_ENABLE_IF(
          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
                                        const T, T>>::value)>
  auto format(U& map, FormatContext& ctx) const -> decltype(ctx.out()) {
    auto out = ctx.out();
    *out++ = '{';
    int i = 0;
    for (const auto& item : map) {
      if (i > 0) out = detail::write_delimiter(out);
      out = detail::write_range_entry<Char>(out, item.first);
      *out++ = ':';
      *out++ = ' ';
      out = detail::write_range_entry<Char>(out, item.second);
      ++i;
    }
    *out++ = '}';
    return out;
  }
 };
 template <typename Char, typename... T> struct tuple_join_view : detail::view {
@ -510,9 +579,6 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
      : tuple(t), sep{s} {}
 };
 template <typename Char, typename... T>
 using tuple_arg_join = tuple_join_view<Char, T...>;
 // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
 // support in tuple_join. It is disabled by default because of issues with
 // the dynamic width and precision.
@ -582,7 +648,45 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
  }
 };
-FMT_MODULE_EXPORT_BEGIN
+namespace detail {
 // Check if T has an interface like a container adaptor (e.g. std::stack,
 // std::queue, std::priority_queue).
 template <typename T> class is_container_adaptor_like {
  template <typename U> static auto check(U* p) -> typename U::container_type;
  template <typename> static void check(...);
 public:
  static constexpr const bool value =
      !std::is_void<decltype(check<T>(nullptr))>::value;
 };
 template <typename Container> struct all {
  const Container& c;
  auto begin() const -> typename Container::const_iterator { return c.begin(); }
  auto end() const -> typename Container::const_iterator { return c.end(); }
 };
 }  // namespace detail
 template <typename T, typename Char>
 struct formatter<
    T, Char,
    enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
                            bool_constant<range_format_kind<T, Char>::value ==
                                          range_format::disabled>>::value>>
    : formatter<detail::all<typename T::container_type>, Char> {
  using all = detail::all<typename T::container_type>;
  template <typename FormatContext>
  auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
    struct getter : T {
      static auto get(const T& t) -> all {
        return {t.*(&getter::c)};  // Access c through the derived class.
      }
    };
    return formatter<all>::format(getter::get(t), ctx);
  }
 };
 FMT_BEGIN_EXPORT
 /**
  \rst
@ -625,7 +729,7 @@ auto join(std::initializer_list<T> list, string_view sep)
  return join(std::begin(list), std::end(list), sep);
 }
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_RANGES_H_
--- a/dep/fmt/include/fmt/std.h
+++ b/dep/fmt/include/fmt/std.h
@ -8,10 +8,18 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_
 #include <atomic>
 #include <bitset>
 #include <cstdlib>
 #include <exception>
 #include <memory>
 #include <thread>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <vector>
 #include "format.h"
 #include "ostream.h"
 #if FMT_HAS_INCLUDE(<version>)
@ -25,6 +33,30 @@
 #  if FMT_HAS_INCLUDE(<variant>)
 #    include <variant>
 #  endif
 #  if FMT_HAS_INCLUDE(<optional>)
 #    include <optional>
 #  endif
 #endif
 // GCC 4 does not support FMT_HAS_INCLUDE.
 #if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
 #  include <cxxabi.h>
 // Android NDK with gabi++ library on some architectures does not implement
 // abi::__cxa_demangle().
 #  ifndef __GABIXX_CXXABI_H__
 #    define FMT_HAS_ABI_CXA_DEMANGLE
 #  endif
 #endif
 // Check if typeid is available.
 #ifndef FMT_USE_TYPEID
 // __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
 #  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
      defined(__INTEL_RTTI__) || defined(__RTTI)
 #    define FMT_USE_TYPEID 1
 #  else
 #    define FMT_USE_TYPEID 0
 #  endif
 #endif
 #ifdef __cpp_lib_filesystem
@ -32,21 +64,32 @@ FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename Char> auto get_path_string(const std::filesystem::path& p) {
  return p.string<Char>();
 }
 template <typename Char>
 void write_escaped_path(basic_memory_buffer<Char>& quoted,
                        const std::filesystem::path& p) {
  write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
 }
 #  ifdef _WIN32
 template <>
-inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
+inline auto get_path_string<char>(const std::filesystem::path& p) {
-                                     const std::filesystem::path& p) {
+  return to_utf8<wchar_t>(p.native(), to_utf8_error_policy::replace);
  auto s = p.u8string();
  write_escaped_string<char>(
      std::back_inserter(quoted),
      string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
 }
-#  endif
+
 template <>
 inline void write_escaped_path<char>(memory_buffer& quoted,
                                     const std::filesystem::path& p) {
  auto buf = basic_memory_buffer<wchar_t>();
  write_escaped_string<wchar_t>(std::back_inserter(buf), p.native());
  bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
  FMT_ASSERT(valid, "invalid utf16");
 }
 #  endif  // _WIN32
 template <>
 inline void write_escaped_path<std::filesystem::path::value_type>(
    basic_memory_buffer<std::filesystem::path::value_type>& quoted,
@ -57,67 +100,118 @@ inline void write_escaped_path<std::filesystem::path::value_type>(
 }  // namespace detail
-#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1920
+FMT_EXPORT
-// For MSVC 2017 and earlier using the partial specialization
+template <typename Char> struct formatter<std::filesystem::path, Char> {
-// would cause an ambiguity error, therefore we provide it only
+ private:
-// conditionally.
+  format_specs<Char> specs_;
-template <typename Char>
+  detail::arg_ref<Char> width_ref_;
-struct formatter<std::filesystem::path, Char>
+  bool debug_ = false;
-    : formatter<basic_string_view<Char>> {
+
 public:
  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& 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);
    if (it != end && *it == '?') {
      debug_ = true;
      ++it;
    }
    return it;
  }
  template <typename FormatContext>
-  auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
-      typename FormatContext::iterator {
+    auto specs = specs_;
-    basic_memory_buffer<Char> quoted;
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                       ctx);
    if (!debug_) {
      auto s = detail::get_path_string<Char>(p);
      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
    }
    auto quoted = basic_memory_buffer<Char>();
    detail::write_escaped_path(quoted, p);
-    return formatter<basic_string_view<Char>>::format(
+    return detail::write(ctx.out(),
-        basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
+                         basic_string_view<Char>(quoted.data(), quoted.size()),
                         specs);
  }
 };
 #endif
 FMT_END_NAMESPACE
 #endif
 FMT_BEGIN_NAMESPACE
 FMT_EXPORT
 template <typename Char>
 struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
 FMT_END_NAMESPACE
-#ifdef __cpp_lib_variant
+#ifdef __cpp_lib_optional
 FMT_BEGIN_NAMESPACE
-template <typename Char> struct formatter<std::monostate, Char> {
+FMT_EXPORT
-  template <typename ParseContext>
+template <typename T, typename Char>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+struct formatter<std::optional<T>, Char,
-    return ctx.begin();
+                 std::enable_if_t<is_formattable<T, Char>::value>> {
 private:
  formatter<T, Char> underlying_;
  static constexpr basic_string_view<Char> optional =
      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
                             '('>{};
  static constexpr basic_string_view<Char> none =
      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
  template <class U>
  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
      -> decltype(u.set_debug_format(set)) {
    u.set_debug_format(set);
  }
  template <class U>
  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
 public:
  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
    maybe_set_debug_format(underlying_, true);
    return underlying_.parse(ctx);
  }
  template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
+  auto format(std::optional<T> const& opt, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    if (!opt) return detail::write<Char>(ctx.out(), none);
    auto out = ctx.out();
-    out = detail::write<Char>(out, "monostate");
+    out = detail::write<Char>(out, optional);
-    return out;
+    ctx.advance_to(out);
    out = underlying_.format(*opt, ctx);
    return detail::write(out, ')');
  }
 };
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_optional
 #ifdef __cpp_lib_variant
 FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename T>
 using variant_index_sequence =
    std::make_index_sequence<std::variant_size<T>::value>;
-// variant_size and variant_alternative check.
+template <typename> struct is_variant_like_ : std::false_type {};
-template <typename T, typename U = void>
+template <typename... Types>
-struct is_variant_like_ : std::false_type {};
+struct is_variant_like_<std::variant<Types...>> : std::true_type {};
 template <typename T>
 struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
    : std::true_type {};
-// formattable element check
+// formattable element check.
 template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... I>
+  template <std::size_t... Is>
  static std::conjunction<
-      is_formattable<std::variant_alternative_t<I, T>, C>...>
+      is_formattable<std::variant_alternative_t<Is, T>, C>...>
-      check(std::index_sequence<I...>);
+      check(std::index_sequence<Is...>);
 public:
  static constexpr const bool value =
@ -145,6 +239,21 @@ template <typename T, typename C> struct is_variant_formattable {
      detail::is_variant_formattable_<T, C>::value;
 };
 FMT_EXPORT
 template <typename Char> struct formatter<std::monostate, Char> {
  template <typename ParseContext>
  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }
  template <typename FormatContext>
  auto format(const std::monostate&, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return detail::write<Char>(ctx.out(), "monostate");
  }
 };
 FMT_EXPORT
 template <typename Variant, typename Char>
 struct formatter<
    Variant, Char,
@ -161,16 +270,196 @@ struct formatter<
    auto out = ctx.out();
    out = detail::write<Char>(out, "variant(");
-    std::visit(
+    FMT_TRY {
-        [&](const auto& v) {
+      std::visit(
-          out = detail::write_variant_alternative<Char>(out, v);
+          [&](const auto& v) {
-        },
+            out = detail::write_variant_alternative<Char>(out, v);
-        value);
+          },
          value);
    }
    FMT_CATCH(const std::bad_variant_access&) {
      detail::write<Char>(out, "valueless by exception");
    }
    *out++ = ')';
    return out;
  }
 };
 FMT_END_NAMESPACE
 #endif  // __cpp_lib_variant
 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 <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(out, ec.category().name(), format_specs<Char>());
    out = detail::write<Char>(out, Char(':'));
    out = detail::write<Char>(out, ec.value());
    return out;
  }
 };
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<
    T, Char,
    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
 private:
  bool with_typename_ = false;
 public:
  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
      -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it == end || *it == '}') return it;
    if (*it == 't') {
      ++it;
      with_typename_ = FMT_USE_TYPEID != 0;
    }
    return it;
  }
  template <typename OutputIt>
  auto format(const std::exception& ex,
              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
    format_specs<Char> spec;
    auto out = ctx.out();
    if (!with_typename_)
      return detail::write_bytes(out, string_view(ex.what()), spec);
 #if FMT_USE_TYPEID
    const std::type_info& ti = typeid(ex);
 #  ifdef FMT_HAS_ABI_CXA_DEMANGLE
    int status = 0;
    std::size_t size = 0;
    std::unique_ptr<char, decltype(&std::free)> demangled_name_ptr(
        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
    string_view demangled_name_view;
    if (demangled_name_ptr) {
      demangled_name_view = demangled_name_ptr.get();
      // Normalization of stdlib inline namespace names.
      // libc++ inline namespaces.
      //  std::__1::*       -> std::*
      //  std::__1::__fs::* -> std::*
      // libstdc++ inline namespaces.
      //  std::__cxx11::*             -> std::*
      //  std::filesystem::__cxx11::* -> std::filesystem::*
      if (demangled_name_view.starts_with("std::")) {
        char* begin = demangled_name_ptr.get();
        char* to = begin + 5;  // std::
        for (char *from = to, *end = begin + demangled_name_view.size();
             from < end;) {
          // This is safe, because demangled_name is NUL-terminated.
          if (from[0] == '_' && from[1] == '_') {
            char* next = from + 1;
            while (next < end && *next != ':') next++;
            if (next[0] == ':' && next[1] == ':') {
              from = next + 2;
              continue;
            }
          }
          *to++ = *from++;
        }
        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
      }
    } else {
      demangled_name_view = string_view(ti.name());
    }
    out = detail::write_bytes(out, demangled_name_view, spec);
 #  elif FMT_MSC_VERSION
    string_view demangled_name_view(ti.name());
    if (demangled_name_view.starts_with("class "))
      demangled_name_view.remove_prefix(6);
    else if (demangled_name_view.starts_with("struct "))
      demangled_name_view.remove_prefix(7);
    out = detail::write_bytes(out, demangled_name_view, spec);
 #  else
    out = detail::write_bytes(out, string_view(ti.name()), spec);
 #  endif
    *out++ = ':';
    *out++ = ' ';
    return detail::write_bytes(out, string_view(ex.what()), spec);
 #endif
  }
 };
 namespace detail {
 template <typename T, typename Enable = void>
 struct has_flip : std::false_type {};
 template <typename T>
 struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
    : std::true_type {};
 template <typename T> struct is_bit_reference_like {
  static constexpr const bool value =
      std::is_convertible<T, bool>::value &&
      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
 };
 #ifdef _LIBCPP_VERSION
 // Workaround for libc++ incompatibility with C++ standard.
 // According to the Standard, `bitset::operator[] const` returns bool.
 template <typename C>
 struct is_bit_reference_like<std::__bit_const_reference<C>> {
  static constexpr const bool value = true;
 };
 #endif
 }  // namespace detail
 // We can't use std::vector<bool, Allocator>::reference and
 // std::bitset<N>::reference because the compiler can't deduce Allocator and N
 // in partial specialization.
 FMT_EXPORT
 template <typename BitRef, typename Char>
 struct formatter<BitRef, Char,
                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
    : formatter<bool, Char> {
  template <typename FormatContext>
  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<bool, Char>::format(v, ctx);
  }
 };
 FMT_EXPORT
 template <typename T, typename Char>
 struct formatter<std::atomic<T>, Char,
                 enable_if_t<is_formattable<T, Char>::value>>
    : formatter<T, Char> {
  template <typename FormatContext>
  auto format(const std::atomic<T>& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<T, Char>::format(v.load(), ctx);
  }
 };
 #ifdef __cpp_lib_atomic_flag_test
 FMT_EXPORT
 template <typename Char>
 struct formatter<std::atomic_flag, Char>
    : formatter<bool, Char> {
  template <typename FormatContext>
  auto format(const std::atomic_flag& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<bool, Char>::format(v.test(), ctx);
  }
 };
 #endif // __cpp_lib_atomic_flag_test
 FMT_END_NAMESPACE
 #endif  // FMT_STD_H_
--- a/dep/fmt/include/fmt/xchar.h
+++ b/dep/fmt/include/fmt/xchar.h
@ -9,17 +9,35 @@
 #define FMT_XCHAR_H_
 #include <cwchar>
 #include <tuple>
 #include "format.h"
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 #  include <locale>
 #endif
 FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
 }
-FMT_MODULE_EXPORT_BEGIN
+inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
                      loc_value value, const format_specs<wchar_t>& specs,
                      locale_ref loc) -> bool {
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
  auto& numpunct =
      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
  auto separator = std::wstring();
  auto grouping = numpunct.grouping();
  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
 #endif
  return false;
 }
 }  // namespace detail
 FMT_BEGIN_EXPORT
 using wstring_view = basic_string_view<wchar_t>;
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
@ -30,9 +48,13 @@ 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>...>;
 inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
  return {{s}};
 }
 #endif
 template <> struct is_char<wchar_t> : std::true_type {};
@ -40,9 +62,9 @@ template <> struct is_char<detail::char8_type> : std::true_type {};
 template <> struct is_char<char16_t> : std::true_type {};
 template <> struct is_char<char32_t> : std::true_type {};
-template <typename... Args>
+template <typename... T>
-constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+constexpr format_arg_store<wformat_context, T...> make_wformat_args(
-    const Args&... args) {
+    const T&... args) {
  return {args...};
 }
@ -77,26 +99,22 @@ template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
 auto vformat(basic_string_view<Char> format_str,
             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buffer;
+  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buffer, format_str, args);
+  detail::vformat_to(buf, format_str, args);
-  return to_string(buffer);
+  return to_string(buf);
 }
 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 409
 template <typename... Args>
 using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
 #endif
 template <typename... T>
 auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
-  return vformat(fmt, fmt::make_wformat_args(args...));
+  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args, typename Char = char_t<S>,
+template <typename S, typename... T, typename Char = char_t<S>,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
-auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+                        !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),
                 fmt::make_format_args<buffer_context<Char>>(args...));
 }
@ -111,11 +129,10 @@ inline auto vformat(
  return detail::vformat(loc, detail::to_string_view(format_str), args);
 }
-template <typename Locale, typename S, typename... Args,
+template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
          typename Char = 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, Args&&... args)
+inline auto format(const Locale& loc, const S& format_str, T&&... args)
    -> std::basic_string<Char> {
  return detail::vformat(loc, detail::to_string_view(format_str),
                         fmt::make_format_args<buffer_context<Char>>(args...));
@ -129,14 +146,14 @@ auto vformat_to(OutputIt out, const S& format_str,
    -> OutputIt {
  auto&& buf = detail::get_buffer<Char>(out);
  detail::vformat_to(buf, detail::to_string_view(format_str), args);
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
  return vformat_to(out, detail::to_string_view(fmt),
                    fmt::make_format_args<buffer_context<Char>>(args...));
 }
@ -152,18 +169,18 @@ inline auto vformat_to(
  auto&& buf = detail::get_buffer<Char>(out);
  vformat_to(buf, detail::to_string_view(format_str), args,
             detail::locale_ref(loc));
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 template <
-    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename OutputIt, typename Locale, typename S, typename... T,
    typename Char = 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,
-                      Args&&... args) ->
+                      T&&... args) ->
    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, to_string_view(format_str),
+  return vformat_to(out, loc, detail::to_string_view(format_str),
                    fmt::make_format_args<buffer_context<Char>>(args...));
 }
@ -174,36 +191,36 @@ inline auto vformat_to_n(
    OutputIt out, size_t n, basic_string_view<Char> format_str,
    basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> format_to_n_result<OutputIt> {
-  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+  using traits = detail::fixed_buffer_traits;
-                                                                           n);
+  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
  detail::vformat_to(buf, format_str, args);
  return {buf.out(), buf.count()};
 }
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
          typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                            detail::is_exotic_char<Char>::value)>
-inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-                        const Args&... args) -> format_to_n_result<OutputIt> {
+    -> format_to_n_result<OutputIt> {
  return vformat_to_n(out, n, detail::to_string_view(fmt),
                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
-template <typename S, typename... Args, typename Char = char_t<S>,
+template <typename S, typename... T, typename Char = char_t<S>,
          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
-inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
-  detail::counting_buffer<Char> buf;
+  auto buf = detail::counting_buffer<Char>();
  detail::vformat_to(buf, detail::to_string_view(fmt),
                     fmt::make_format_args<buffer_context<Char>>(args...));
  return buf.count();
 }
 inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  wmemory_buffer buffer;
+  auto buf = wmemory_buffer();
-  detail::vformat_to(buffer, fmt, args);
+  detail::vformat_to(buf, fmt, args);
-  buffer.push_back(L'\0');
+  buf.push_back(L'\0');
-  if (std::fputws(buffer.data(), f) == -1)
+  if (std::fputws(buf.data(), f) == -1)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
@ -220,13 +237,22 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 template <typename... T>
 void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }
 template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
  return print(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);
 }
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 #endif  // FMT_XCHAR_H_
--- a/dep/fmt/src/fmt.cc
+++ b/dep/fmt/src/fmt.cc
@ -1,49 +1,44 @@
 module;
 #ifndef __cpp_modules
 #  error Module not supported.
 #endif
 // put all implementation-provided headers into the global module fragment
 // to prevent attachment to this module
 #if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
 #  define _CRT_SECURE_NO_WARNINGS
 #endif
 #if !defined(WIN32_LEAN_AND_MEAN) && defined(_WIN32)
 #  define WIN32_LEAN_AND_MEAN
 #endif
 // Put all implementation-provided headers into the global module fragment
 // to prevent attachment to this module.
 #include <algorithm>
 #include <cctype>
 #include <cerrno>
 #include <chrono>
 #include <climits>
 #include <clocale>
 #include <cmath>
 #include <cstdarg>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <cwchar>
 #include <exception>
 #include <filesystem>
 #include <fstream>
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <locale>
 #include <memory>
 #include <optional>
 #include <ostream>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <string_view>
 #include <system_error>
 #include <thread>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <variant>
 #include <vector>
 #include <version>
-#if _MSC_VER
+#if __has_include(<cxxabi.h>)
 #  include <cxxabi.h>
 #endif
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #  include <intrin.h>
 #endif
 #if defined __APPLE__ || defined(__FreeBSD__)
@ -65,22 +60,33 @@ module;
 #  endif
 #endif
 #ifdef _WIN32
 #  if defined(__GLIBCXX__)
 #    include <ext/stdio_filebuf.h>
 #    include <ext/stdio_sync_filebuf.h>
 #  elif defined(_LIBCPP_VERSION)
 #    include <__std_stream>
 #  endif
 #  define WIN32_LEAN_AND_MEAN
 #  include <windows.h>
 #endif
 export module fmt;
-#define FMT_MODULE_EXPORT export
+#define FMT_EXPORT export
-#define FMT_MODULE_EXPORT_BEGIN export {
+#define FMT_BEGIN_EXPORT export {
-#define FMT_MODULE_EXPORT_END }
+#define FMT_END_EXPORT }
-#define FMT_BEGIN_DETAIL_NAMESPACE \
+
-  }                                \
+// If you define FMT_ATTACH_TO_GLOBAL_MODULE
-  namespace detail {
+//  - all declarations are detached from module 'fmt'
-#define FMT_END_DETAIL_NAMESPACE \
+//  - the module behaves like a traditional static library, too
-  }                              \
+//  - all library symbols are mangled traditionally
-  export {
+//  - you can mix TUs with either importing or #including the {fmt} API
-// all library-provided declarations and definitions
+#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
-// must be in the module purview to be exported
+extern "C++" {
 #endif
 // All library-provided declarations and definitions must be in the module
 // purview to be exported.
 #include "fmt/args.h"
 #include "fmt/chrono.h"
 #include "fmt/color.h"
@ -88,8 +94,13 @@ export module fmt;
 #include "fmt/format.h"
 #include "fmt/os.h"
 #include "fmt/printf.h"
 #include "fmt/std.h"
 #include "fmt/xchar.h"
 #ifdef FMT_ATTACH_TO_GLOBAL_MODULE
 }
 #endif
 // gcc doesn't yet implement private module fragments
 #if !FMT_GCC_VERSION
 module : private;
--- a/dep/fmt/src/format.cc
+++ b/dep/fmt/src/format.cc
@ -28,12 +28,8 @@ template FMT_API auto decimal_point_impl(locale_ref) -> char;
 template FMT_API void buffer<char>::append(const char*, const char*);
 // DEPRECATED!
 // There is no correspondent extern template in format.h because of
 // incompatibility between clang and gcc (#2377).
 template FMT_API void vformat_to(buffer<char>&, string_view,
-                                 basic_format_args<FMT_BUFFER_CONTEXT(char)>,
+                                 typename vformat_args<>::type, locale_ref);
                                 locale_ref);
 // Explicit instantiations for wchar_t.
--- a/dep/fmt/src/os.cc
+++ b/dep/fmt/src/os.cc
@ -18,6 +18,10 @@
 #  include <sys/stat.h>
 #  include <sys/types.h>
 #  ifdef _WRS_KERNEL   // VxWorks7 kernel
 #    include <ioLib.h> // getpagesize
 #  endif
 #  ifndef _WIN32
 #    include <unistd.h>
 #  else
@ -72,34 +76,6 @@ inline std::size_t convert_rwcount(std::size_t count) { return count; }
 FMT_BEGIN_NAMESPACE
 #ifdef _WIN32
 detail::utf16_to_utf8::utf16_to_utf8(basic_string_view<wchar_t> s) {
  if (int error_code = convert(s)) {
    FMT_THROW(windows_error(error_code,
                            "cannot convert string from UTF-16 to UTF-8"));
  }
 }
 int detail::utf16_to_utf8::convert(basic_string_view<wchar_t> s) {
  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
  int s_size = static_cast<int>(s.size());
  if (s_size == 0) {
    // WideCharToMultiByte does not support zero length, handle separately.
    buffer_.resize(1);
    buffer_[0] = 0;
    return 0;
  }
  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
                                   nullptr, nullptr);
  if (length == 0) return GetLastError();
  buffer_.resize(length + 1);
  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
                               length, nullptr, nullptr);
  if (length == 0) return GetLastError();
  buffer_[length] = 0;
  return 0;
 }
 namespace detail {
 class system_message {
@ -138,10 +114,10 @@ class utf8_system_category final : public std::error_category {
 public:
  const char* name() const noexcept override { return "system"; }
  std::string message(int error_code) const override {
-    system_message msg(error_code);
+    auto&& msg = system_message(error_code);
    if (msg) {
-      utf16_to_utf8 utf8_message;
+      auto utf8_message = to_utf8<wchar_t>();
-      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+      if (utf8_message.convert(msg)) {
        return utf8_message.str();
      }
    }
@ -165,11 +141,12 @@ std::system_error vwindows_error(int err_code, string_view format_str,
 void detail::format_windows_error(detail::buffer<char>& out, int error_code,
                                  const char* message) noexcept {
  FMT_TRY {
-    system_message msg(error_code);
+    auto&& msg = system_message(error_code);
    if (msg) {
-      utf16_to_utf8 utf8_message;
+      auto utf8_message = to_utf8<wchar_t>();
-      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+      if (utf8_message.convert(msg)) {
-        fmt::format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
+        fmt::format_to(appender(out), FMT_STRING("{}: {}"), message,
                       string_view(utf8_message));
        return;
      }
    }
@ -192,37 +169,47 @@ buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
                nullptr);
  if (!file_)
-    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+    FMT_THROW(system_error(errno, FMT_STRING("cannot open file {}"),
                           filename.c_str()));
 }
 void buffered_file::close() {
  if (!file_) return;
  int result = FMT_SYSTEM(fclose(file_));
  file_ = nullptr;
-  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+  if (result != 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
 }
 int buffered_file::descriptor() const {
 #ifdef fileno  // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
  int fd = fileno(file_);
 #else
  int fd = FMT_POSIX_CALL(fileno(file_));
-  if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
+#endif
  if (fd == -1)
    FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor")));
  return fd;
 }
 #if FMT_USE_FCNTL
 file::file(cstring_view path, int oflag) {
 #  ifdef _WIN32
-  using mode_t = int;
+using mode_t = int;
 #  endif
-  constexpr mode_t mode =
+constexpr mode_t default_open_mode =
-      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 file::file(cstring_view path, int oflag) {
 #  if defined(_WIN32) && !defined(__MINGW32__)
  fd_ = -1;
-  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
+  auto converted = detail::utf8_to_utf16(string_view(path.c_str()));
  *this = file::open_windows_file(converted.c_str(), oflag);
 #  else
-  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
+  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, default_open_mode)));
 #  endif
  if (fd_ == -1)
-    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
+    FMT_THROW(
        system_error(errno, FMT_STRING("cannot open file {}"), path.c_str()));
 #  endif
 }
 file::~file() noexcept {
@ -238,7 +225,8 @@ void file::close() {
  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
  int result = FMT_POSIX_CALL(close(fd_));
  fd_ = -1;
-  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+  if (result != 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
 }
 long long file::size() const {
@ -260,7 +248,7 @@ long long file::size() const {
  using Stat = struct stat;
  Stat file_stat = Stat();
  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
-    FMT_THROW(system_error(errno, "cannot get file attributes"));
+    FMT_THROW(system_error(errno, FMT_STRING("cannot get file attributes")));
  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
                "return type of file::size is not large enough");
  return file_stat.st_size;
@ -270,14 +258,16 @@ long long file::size() const {
 std::size_t file::read(void* buffer, std::size_t count) {
  rwresult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
-  if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
+  if (result < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
  return detail::to_unsigned(result);
 }
 std::size_t file::write(const void* buffer, std::size_t count) {
  rwresult result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
-  if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
+  if (result < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
  return detail::to_unsigned(result);
 }
@ -286,7 +276,8 @@ file file::dup(int fd) {
  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
  int new_fd = FMT_POSIX_CALL(dup(fd));
  if (new_fd == -1)
-    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
+    FMT_THROW(system_error(
        errno, FMT_STRING("cannot duplicate file descriptor {}"), fd));
  return file(new_fd);
 }
@ -294,8 +285,9 @@ void file::dup2(int fd) {
  int result = 0;
  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
  if (result == -1) {
-    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}",
+    FMT_THROW(system_error(
-                           fd_, fd));
+        errno, FMT_STRING("cannot duplicate file descriptor {} to {}"), fd_,
        fd));
  }
 }
@ -320,7 +312,8 @@ void file::pipe(file& read_end, file& write_end) {
  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
  int result = FMT_POSIX_CALL(pipe(fds));
 #  endif
-  if (result != 0) FMT_THROW(system_error(errno, "cannot create pipe"));
+  if (result != 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
  // The following assignments don't throw because read_fd and write_fd
  // are closed.
  read_end = file(fds[0]);
@ -334,28 +327,72 @@ buffered_file file::fdopen(const char* mode) {
 #  else
  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
 #  endif
-  if (!f)
+  if (!f) {
-    FMT_THROW(
+    FMT_THROW(system_error(
-        system_error(errno, "cannot associate stream with file descriptor"));
+        errno, FMT_STRING("cannot associate stream with file descriptor")));
  }
  buffered_file bf(f);
  fd_ = -1;
  return bf;
 }
 #  if defined(_WIN32) && !defined(__MINGW32__)
 file file::open_windows_file(wcstring_view path, int oflag) {
  int fd = -1;
  auto err = _wsopen_s(&fd, path.c_str(), oflag, _SH_DENYNO, default_open_mode);
  if (fd == -1) {
    FMT_THROW(system_error(err, FMT_STRING("cannot open file {}"),
                           detail::to_utf8<wchar_t>(path.c_str()).c_str()));
  }
  return file(fd);
 }
 #  endif
 #  if !defined(__MSDOS__)
 long getpagesize() {
-#  ifdef _WIN32
+#    ifdef _WIN32
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return si.dwPageSize;
-#  else
+#    else
 #      ifdef _WRS_KERNEL
  long size = FMT_POSIX_CALL(getpagesize());
 #      else
  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
-  if (size < 0) FMT_THROW(system_error(errno, "cannot get memory page size"));
+#      endif
  return size;
 #  endif
 }
-FMT_API void ostream::grow(size_t) {
+  if (size < 0)
    FMT_THROW(system_error(errno, FMT_STRING("cannot get memory page size")));
  return size;
 #    endif
 }
 #  endif
 namespace detail {
 void file_buffer::grow(size_t) {
  if (this->size() == this->capacity()) flush();
 }
 file_buffer::file_buffer(cstring_view path,
                         const detail::ostream_params& params)
    : file_(path, params.oflag) {
  set(new char[params.buffer_size], params.buffer_size);
 }
 file_buffer::file_buffer(file_buffer&& other)
    : detail::buffer<char>(other.data(), other.size(), other.capacity()),
      file_(std::move(other.file_)) {
  other.clear();
  other.set(nullptr, 0);
 }
 file_buffer::~file_buffer() {
  flush();
  delete[] data();
 }
 }  // namespace detail
 ostream::~ostream() = default;
 #endif  // FMT_USE_FCNTL
 FMT_END_NAMESPACE
--- a/dep/fmt/support/cmake/cxx14.cmake
+++ b/dep/fmt/support/cmake/cxx14.cmake
@ -1,54 +0,0 @@
 # C++14 feature support detection
 include(CheckCXXCompilerFlag)
 function (fmt_check_cxx_compiler_flag flag result)
  if (NOT MSVC)
    check_cxx_compiler_flag("${flag}" ${result})
  endif ()
 endfunction ()
 if (NOT CMAKE_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 11)
 endif()
 message(STATUS "CXX_STANDARD: ${CMAKE_CXX_STANDARD}")
 if (CMAKE_CXX_STANDARD EQUAL 20)
  fmt_check_cxx_compiler_flag(-std=c++20 has_std_20_flag)
  fmt_check_cxx_compiler_flag(-std=c++2a has_std_2a_flag)
  if (has_std_20_flag)
    set(CXX_STANDARD_FLAG -std=c++20)
  elseif (has_std_2a_flag)
    set(CXX_STANDARD_FLAG -std=c++2a)
  endif ()
 elseif (CMAKE_CXX_STANDARD EQUAL 17)
  fmt_check_cxx_compiler_flag(-std=c++17 has_std_17_flag)
  fmt_check_cxx_compiler_flag(-std=c++1z has_std_1z_flag)
  if (has_std_17_flag)
    set(CXX_STANDARD_FLAG -std=c++17)
  elseif (has_std_1z_flag)
    set(CXX_STANDARD_FLAG -std=c++1z)
  endif ()
 elseif (CMAKE_CXX_STANDARD EQUAL 14)
  fmt_check_cxx_compiler_flag(-std=c++14 has_std_14_flag)
  fmt_check_cxx_compiler_flag(-std=c++1y has_std_1y_flag)
  if (has_std_14_flag)
    set(CXX_STANDARD_FLAG -std=c++14)
  elseif (has_std_1y_flag)
    set(CXX_STANDARD_FLAG -std=c++1y)
  endif ()
 elseif (CMAKE_CXX_STANDARD EQUAL 11)
  fmt_check_cxx_compiler_flag(-std=c++11 has_std_11_flag)
  fmt_check_cxx_compiler_flag(-std=c++0x has_std_0x_flag)
  if (has_std_11_flag)
    set(CXX_STANDARD_FLAG -std=c++11)
  elseif (has_std_0x_flag)
    set(CXX_STANDARD_FLAG -std=c++0x)
  endif ()
 endif ()