Log message:
*: replace CMAKE_ARGS with CMAKE_CONFIGURE_ARGS

Log message:
fmtlib: updated to 11.0.2

11.0.2

Fixed compatibility with non-POSIX systems
Fixed performance regressions when using std::back_insert_iterator with \ 
fmt::format_to
Fixed handling of std::generator and move-only iterators
Made formatter<std::string_view>::parse work with types convertible to \ 
std::string_view
Made volatile void* formattable
Made Glib::ustring not be confused with std::string
Made fmt::context iterator compatible with STL algorithms that rely on iterator \ 
category

Log message:
Revbump for fmtlib 11.0.1
Pointed out by David Gutteridge on pkgsrc-changes

Log message:
Update fmtlib to 11.0.1

Many improvemnts. Highlights include:

- Added formatters for `std::chrono::day`, `std::chrono::month`,
  `std::chrono::year` and `std::chrono::year_month_day`
- Fixed handling of precision in `%S` (https://github.com/fmtlib/fmt/issues/3794,
- Added a formatter for `std::complex`
- Added a formatter for `std::expected`
- Added a formatter for `std::type_info`

and much faster compile times even without using the new cut down
fmt/base.h which provides the printf() equivalent family of functions.

For a full list see https://github.com/fmtlib/fmt/blob/11.0.1/ChangeLog.md

Log message:
fmtlib: updated to 10.2.1

10.2.1 - 2024-01-03

-   Fixed ABI compatibility with earlier 10.x versions

10.2.0 - 2024-01-01

-   Added support for the `%j` specifier (the number of days) for
    `std::chrono::duration`

-   Added support for the chrono suffix for days and changed
    the suffix for minutes from "m" to the correct "min"
    For example ([godbolt](https://godbolt.org/z/9KhMnq9ba)):

    ```c++
    #include <fmt/chrono.h>

    int main() {
      fmt::print("{}\n", std::chrono::days(42)); // prints "42d"
    }
    ```

-   Fixed an overflow in `std::chrono::time_point` formatting with large dates
-   Added a formatter for `std::source_location`
    For example ([godbolt](https://godbolt.org/z/YajfKjhhr)):

    ```c++
    #include <source_location>
    #include <fmt/std.h>

    int main() {
      fmt::print("{}\n", std::source_location::current());
    }
    ```

    prints

    ```
    /app/example.cpp:5:51: int main()
    ```

-   Added a formatter for `std::bitset`

    ```c++
    #include <bitset>
    #include <fmt/std.h>

    int main() {
      fmt::print("{}\n", std::bitset<6>(42)); // prints \ 
"101010"
    }
    ```

-   Added an experimental `nested_formatter` that provides an easy way of
    applying a formatter to one or more subobjects while automatically handling
    width, fill and alignment. For example:

    ```c++
    #include <fmt/format.h>

    struct point {
      double x, y;
    };

    template <>
    struct fmt::formatter<point> : nested_formatter<double> {
      auto format(point p, format_context& ctx) const {
        return write_padded(ctx, [=](auto out) {
          return format_to(out, "({}, {})", nested(p.x), nested(p.y));
        });
      }
    };

    int main() {
      fmt::print("[{:>20.2f}]", point{1, 2});
    }
    ```

    prints

    ```
    [          (1.00, 2.00)]
    ```

-   Added the generic representation (`g`) to `std::filesystem::path`

    ```c++
    #include <filesystem>
    #include <fmt/std.h>

    int main() {
      fmt::print("{:g}\n", std::filesystem::path("C:\\foo"));
    }
    ```

    prints `"C:/foo"` on Windows.

-   Made `format_as` work with references
-   Fixed formatting of invalid UTF-8 with precision
-   Fixed an inconsistency between `fmt::to_string` and `fmt::format`
-   Disallowed unsafe uses of `fmt::styled`

    ```c++
    auto s = fmt::styled(std::string("dangle"), fmt::emphasis::bold);
    fmt::print("{}\n", s); // compile error
    ```

    Pass `fmt::styled(...)` as a parameter instead.

-   Added a null check when formatting a C string with the `s` specifier
-   Disallowed the `c` specifier for `bool`
-   Made the default formatting unlocalized in `fmt::ostream_formatter` for
    consistency with the rest of the library
-   Fixed localized formatting in bases other than decimal
-   Fixed a performance regression in experimental `fmt::ostream::print`
-   Added synchronization with the underlying output stream when writing to
    the Windows console
-   Changed to only export `format_error` when {fmt} is built as a shared
    library
-   Made `fmt::streamed` `constexpr`.
-   Enabled `consteval` on older versions of MSVC
-   Added an option to build without `wchar_t` support on Windows
-   Improved build and CI configuration
-   Fixed various warnings, compilation and test issues
-   Improved documentation and README
-   Updated CI dependencies

Log message:
fmtlib: updated to 10.1.1

10.1.1

Added formatters for std::atomic and atomic_flag
Fixed an error about partial specialization of formatter<string> after \ 
instantiation when compiled with gcc and C++20
Fixed compilation as a C++20 module with gcc and clang
Made fmt::to_string work with types that have format_as overloads
Made formatted_size work with integral format specifiers at compile time
Fixed a warning about the no_unique_address attribute on clang-cl
Improved compatibility with the legacy GBK encoding
Added OpenSSF Scorecard analysis
Updated CI dependencies

Log message:
fmtlib: update to 10.1.0

From the release information on GitHub:

  * 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
  * Optimized storage of an empty allocator in basic_memory_buffer
  * Added formatters for proxy references to elements of
    std::vector<bool> and std::bitset<N>
  * Fixed an ambiguous formatter specialization for containers that look
    like container adaptors such as boost::flat_set
  * Fixed compilation when formatting durations not convertible from
    std::chrono::seconds
  * Made the formatter specialization for char* const-correct
  * Made {} and {:} handled consistently during compile-time checks
  * Disallowed passing temporaries to make_format_args to improve API
    safety by preventing dangling references
  * Improved the compile-time error for unformattable types
  * Improved the floating-point formatter
  * Fixed handling of precision for long double larger than 64 bits
  * Made floating-point and chrono tests less platform-dependent
  * 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
  * Made FMT_THROW assert even if assertions are disabled when compiling
    with exceptions disabled
  * Added support for the ? format specifier to std::filesystem::path
    and made the default unescaped for consistency with strings
  * Made format_as and std::filesystem::path formatter work with exotic
    code unit types
  * Deprecated the wide stream overload of printf
  * Removed unused basic_printf_parse_context.
  * Improved RTTI detection used when formatting exceptions
  * Improved compatibility with VxWorks7
  * Improved documentation
  * Improved build and CI configurations
  * Fixed various warnings and compilation issues

Log message:
*: PKGREVISION bump for fmtlib shlib major bump

Log message:
fmtlib: update to 10.0.0.

10.0.0 - 2023-05-09
-------------------

* Replaced Grisu with a new floating-point formatting algorithm for given
  precision
  The new algorithm is based on Dragonbox already used for the
  shortest representation and gives substantial performance improvement:

* Replaced ``snprintf``-based hex float formatter with an internal
  implementation
  This removes the last usage of ``s(n)printf`` in {fmt}.

* Fixed alignment of floating-point numbers with localization

* Improved C++20 module support
  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

* Implemented formatting of subseconds

* Added precision support to ``%S``

* Added support for ``std::utc_time``

* Switched formatting of ``std::chrono::system_clock`` from local time to UTC
  for compatibility with the standard

* Added support for ``%Ez`` and ``%Oz`` to chrono formatters.

* Improved validation of format specifiers for ``std::chrono::duration``

* Fixed formatting of time points before the epoch

* Experimental: implemented glibc extension for padding seconds, minutes and
  hours

* Added a formatter for ``std::exception``

* Moved ``std::error_code`` formatter from ``fmt/os.h`` to ``fmt/std.h``.

* Added formatters for standard container adapters: ``std::priority_queue``,
  ``std::queue`` and ``std::stack``

* Added a formatter for ``std::optional`` to ``fmt/std.h``.

* Fixed formatting of valueless by exception variants

* Made ``fmt::ptr`` accept ``unique_ptr`` with a custom deleter

* Fixed formatting of noncopyable ranges and nested ranges of chars

* Fixed issues with formatting of paths and ranges of paths

* Improved handling of invalid Unicode in paths.

* Enabled compile-time checks on Apple clang 14 and later

* Improved compile-time checks of named arguments

* Fixed formatting when both alignment and ``0`` are given

* Improved Unicode support in the experimental file API on Windows

* Unified UTF transcoding

* Added support for UTF-8 digit separators via an experimental locale facet

* Added an overload of ``formatted_size`` that takes a locale

* Removed the deprecated ``FMT_DEPRECATED_OSTREAM``.

* Fixed a UB when using a null ``std::string_view`` with ``fmt::to_string``
  or format string compilation

* Added ``starts_with`` to the fallback ``string_view`` implementation

* Added ``fmt::basic_format_string::get()`` for compatibility with
  ``basic_format_string``

* Added ``println`` for compatibility with C++23

* Improved documentation

* Improved build configuration and tests

* Fixed a regression in handling empty format specifiers after a colon (``{:}``)

* Worked around a broken implementation of ``std::is_constant_evaluated`` in
  some versions of libstdc++ on clang

* Fixed formatting of volatile variables

* Fixed various warnings and compilation issues

Log message:
*: convert to cmake/build.mk