Merge branch 'insp4' into master.

2025-03-09 10:39:02 -04:00 · 2025-01-17 13:43:05 +00:00 · 2025-01-17 13:43:05 +00:00 · 7dbbc78421
commit 7dbbc78421
parent 92bc17740a eaac5cebe1
39 changed files with 3922 additions and 4237 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -33,7 +33,8 @@ Tick the boxes for the checks you have made.

 I have ensured that:

-  - [ ] The code I am submitting is my own work and/or I have permission from the author to share it.
-  - [ ] I have documented any features added by this pull request.
-  - [ ] This pull request does not introduce any incompatible API changes (stable branches only).
-  - [ ] If ABI changes have been made I have incremented MODULE_ABI in `moduledefs.h` (stable branches only).
+- [ ] The code I am submitting is my own work and/or I have permission from the author to share it.
+- [ ] Generative AI (Copilot, ChatGPT, etc) was not used to create any part of this pull request.
+- [ ] I have documented any features added by this pull request.
+- [ ] This pull request does not introduce any incompatible API changes (stable branches only, delete if not applicable).
+- [ ] If ABI changes have been made I have incremented MODULE_ABI in `moduledefs.h` (stable branches only, delete if not applicable).
--- a/.github/workflows/ci-irctest.yml
+++ b/.github/workflows/ci-irctest.yml
@ -16,7 +16,7 @@ on:
 jobs:
  build:
    if: "!contains(github.event.head_commit.message, '[skip irctest ci]')"
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04-arm
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@ -47,7 +47,7 @@ jobs:

  test:
    if: "!contains(github.event.head_commit.message, '[skip irctest ci]')"
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04-arm
    env:
      IRCTEST_DEBUG_LOGS: "1"
    needs:
--- a/.github/workflows/ci-windows.yml
+++ b/.github/workflows/ci-windows.yml
@ -22,7 +22,7 @@ jobs:
      - name: Setup Conan
        uses: turtlebrowser/get-conan@v1.2
        with:
-          version: 1.65.0
+          version: 1.66.0

      - name: Install libraries
        working-directory: ${{ github.workspace }}/win/build
--- a/docs/AUTHORS.txt
+++ b/docs/AUTHORS.txt
@ -1,4 +1,4 @@
-Since the first commit in January 2003 109 people have submitted patches,
+Since the first commit in January 2003 111 people have submitted patches,
 commits, and other useful contributions to InspIRCd. These people, ordered by
 the number of contributions they have made, are:

@ -52,6 +52,7 @@ the number of contributions they have made, are:
  * Chin Lee <kwangchin@gmail.com>
  * Christopher 'm4z' Holm <them4z@gmail.com>
  * eggy
+  * Glen Miner <shaggie76@gmail.com>
  * Guillaume Delacour <gui@iroqwa.org>
  * James Lu <GLolol@overdrivenetworks.com>
  * JD Horelick <jdhore1@gmail.com>
@ -93,6 +94,7 @@ the number of contributions they have made, are:
  * Josh Soref
  * Julien Vehent <julien@linuxwall.info>
  * JustArchi <JustArchi@JustArchi.net>
+  * Larry Williamson <l422y@l422y.com>
  * Matthew Martin <phy1729@gmail.com>
  * newuser1 <flirtex@gmail.com>
  * nia <nia@netbsd.org>
--- a/docs/conf/help.example.conf
+++ b/docs/conf/help.example.conf
@ -1041,31 +1041,42 @@ Note that all /STATS use is broadcast to online server operators.
 ">

 <helptopic key="snomasks" title="Server Notice Masks" value="
- a      Allows receipt of local announcement messages.
- A      Allows receipt of remote announcement messages.
- c      Allows receipt of local connect messages.
- C      Allows receipt of remote connect messages.
- d      Allows receipt of local DNSBL messages (requires the dnsbl module).
- D      Allows receipt of remote DNSBL messages (requires the dnsbl module).
- f      Allows receipt of local filter messages (requires the filter module).
- F      Allows receipt of remote filter messages (requires the filter module).
- g      Allows receipt of globops (requires the globops module).
- j      Allows receipt of channel creation notices (requires the chancreate module).
- J      Allows receipt of remote channel creation notices (requires the chancreate module).
- k      Allows receipt of local kill messages.
- K      Allows receipt of remote kill messages.
- l      Allows receipt of local linking related messages.
- L      Allows receipt of remote linking related messages.
- n      Allows receipt of local nickname changes (requires the seenicks module).
- N      Allows receipt of remote nickname changes (requires the seenicks modules).
- o      Allows receipt of oper-up, oper-down, and oper-failure messages.
- O      Allows receipt of remote oper-up, oper-down, and oper-failure messages.
- q      Allows receipt of local quit messages.
- Q      Allows receipt of remote quit messages.
- t      Allows receipt of attempts to use /STATS (local and remote).
- v      Allows receipt of oper override notices (requires the override module).
- x      Allows receipt of local X-line notices (G/Z/Q/K/E/R/SHUN/CBan).
- X      Allows receipt of remote X-line notices (G/Z/Q/K/E/R/SHUN/CBan).
+A    Notifications about unspecified events on a remote server.
+a    Notifications about unspecified events on the local server.
+C    Notifications about users connecting to a remote server.
+c    Notifications about users connecting to the local server.
+D    Notifications about DNSBL hits on a remote server (requires the dnsbl module).
+d    Notifications about DNSBL hits on the local server (requires the dnsbl module).
+F    Notifications about filter matches on a remote server (requires the filter module).
+f    Notifications about filter matches on the local server (requires the filter module).
+G    Messages from server operators on a remote server (requires the globops module).
+g    Messages from server operators on the local server (requires the globops module).
+J    Notifications about channels being created on a remote server (requires the chancreate module).
+j    Notifications about channels being created on the local server (requires the chancreate
+     module).
+K    Notifications about users being killed on a remote server.
+k    Notifications about users being killed on the local server.
+L    Messages relating to server linking on a remote server (requires the spanningtree module).
+l    Messages relating to server linking on the local server (requires the spanningtree module).
+N    Notifications about nicknames being changed on a remote server (requires the seenicks module).
+n    Notifications about nicknames being changed on the local server (requires the seenicks module).
+O    Notifications about users logging in and out of server operator accounts on a remote server.
+o    Notifications about users logging in and out of server operator accounts on the local server.
+Q    Notifications about users disconnecting from a remote server.
+q    Notifications about users disconnecting from the local server.
+R    Notifications about a remote server rehashing.
+r    Notifications about the local server rehashing.
+t    Notifications about local and remote attempts to use the /STATS command.
+V    Notifications about server operators overriding channel-level restrictions on a remote server
+     (requires the override module).
+v    Notifications about server operators overriding channel-level restrictions on the local server
+     (requires the override module).
+W    Notifications about gateways changing IP addresses on a remote server (requires the gateway
+     module).
+w    Notifications about gateways changing IP addresses on the local server (requires the gateway
+     module).
+X    Notifications about X-lines being added/removed/expired on a remote server.
+x    Notifications about X-lines being added/removed/expired on the local server.
 ">

 <helptopic key="extbans" title="Extended Bans" value="
--- a/docs/conf/providers/dronebl.example.conf
+++ b/docs/conf/providers/dronebl.example.conf
@ -8,7 +8,7 @@
       records="3,5,6,7,8,9,10,11,13,14,15,16,17,19"
       action="zline"
       duration="7d"
-       reason="You are listed in DroneBL: %reason%. Please visit https://dronebl.org/lookup.do?ip=%ip%&amp;network=%network.url% for more information.">
+       reason="You are listed in DroneBL: %reason%. Please visit https://dronebl.org/lookup?ip=%ip%&amp;network=%network.url% for more information.">

 <dnsblreply name="DroneBL"
            reply="1"
--- a/include/channels.h
+++ b/include/channels.h
@ -1,6 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
+ *   Copyright (C) 2024 Glen Miner <shaggie76@gmail.com>
 *   Copyright (C) 2013-2014, 2016, 2018 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2012-2013, 2018-2023 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2012 Robby <robby@chatbelgie.be>
@ -43,7 +44,7 @@ class CoreExport Channel final
 public:
 	/** A map of Memberships on a channel keyed by User pointers
 	 */
-	typedef std::map<User*, insp::aligned_storage<Membership>> MemberMap;
+	typedef std::unordered_map<User*, insp::aligned_storage<Membership>> MemberMap;

 private:
 	/** Set default modes for the channel on creation
--- a/include/logging.h
+++ b/include/logging.h
@ -51,6 +51,12 @@ namespace Log

 		/** A sensitive message that we should not store lightly. */
 		RAWIO = 4,
+
+		/** The lowest log level supported. */
+		LOWEST = CRITICAL,
+
+		/** The highest log level supported. */
+		HIGHEST = RAWIO,
 	};

 	/** Converts a log level to a string.
@ -236,8 +242,11 @@ private:
 	/** Whether we are currently logging to a file. */
 	bool logging = false;

-	/** Check whether raw logging is enabled. */
-	void CheckRawLog();
+	/** The highest level that loggers will accept. */
+	Log::Level maxlevel = Level::HIGHEST;
+
+	/** Check for the highest log level and warn about raw logging */
+	void CheckLevel();

 	/** Writes a message to the server log.
 	 * @param level The level to log at.
@ -246,6 +255,15 @@ private:
 	 */
 	void Write(Level level, const std::string& type, const std::string& message);

+	template <typename... Args>
+	void Write(Level level, const std::string& type, const char* format, Args&&... args)
+	{
+		if (maxlevel < level && !caching)
+			return; // No loggers care about this message.
+
+		Write(level, type, FMT::vformat(format, FMT::make_format_args(args...)));
+	}
+
 public:
 	Manager();

@ -283,7 +301,7 @@ public:
 	template <typename... Args>
 	void Critical(const std::string& type, const char* format, Args&&... args)
 	{
-		Write(Level::CRITICAL, type, FMT::vformat(format, FMT::make_format_args(args...)));
+		Write(Level::CRITICAL, type, format, std::forward<Args>(args)...);
 	}

 	/** Writes a warning message to the server log.
@ -303,7 +321,7 @@ public:
 	template <typename... Args>
 	void Warning(const std::string& type, const char* format, Args&&... args)
 	{
-		Write(Level::WARNING, type, FMT::vformat(format, FMT::make_format_args(args...)));
+		Write(Level::WARNING, type, format, std::forward<Args>(args)...);
 	}

 	/** Writes a normal message to the server log.
@ -323,7 +341,7 @@ public:
 	template <typename... Args>
 	void Normal(const std::string& type, const char* format, Args&&... args)
 	{
-		Write(Level::NORMAL, type, FMT::vformat(format, FMT::make_format_args(args...)));
+		Write(Level::NORMAL, type, format, std::forward<Args>(args)...);
 	}

 	/** Writes a debug message to the server log.
@ -342,7 +360,7 @@ public:
 	template <typename... Args>
 	void Debug(const std::string& type, const char* format, Args&&... args)
 	{
-		Write(Level::DEBUG, type, FMT::vformat(format, FMT::make_format_args(args...)));
+		Write(Level::DEBUG, type, format, std::forward<Args>(args)...);
 	}

 	/** Writes a raw I/O message to the server log.
@ -362,6 +380,6 @@ public:
 	template <typename... Args>
 	void RawIO(const std::string& type, const char* format, Args&&... args)
 	{
-		Write(Level::RAWIO, type, FMT::vformat(format, FMT::make_format_args(args...)));
+		Write(Level::RAWIO, type, format, std::forward<Args>(args)...);
 	}
 };
--- a/make/template/inspircd
+++ b/make/template/inspircd
@ -5,7 +5,7 @@
 #
 #   Copyright (C) 2015 Steven Van Acker <steven@singularity.be>
 #   Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com>
-#   Copyright (C) 2014, 2016, 2019-2021, 2023-2024 Sadie Powell <sadie@witchery.services>
+#   Copyright (C) 2014, 2016, 2019, 2021, 2023-2024 Sadie Powell <sadie@witchery.services>
 #   Copyright (C) 2014 Dan Parsons <dparsons@nyip.net>
 #   Copyright (C) 2012 Robby <robby@chatbelgie.be>
 #   Copyright (C) 2011 DjSlash <djslash@djslash.org>
--- a/modules/botmode.cpp
+++ b/modules/botmode.cpp
@ -1,7 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
- *   Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2012, 2015 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2012 Robby <robby@chatbelgie.be>
 *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
--- a/modules/core/core_channel/extban.cpp
+++ b/modules/core/core_channel/extban.cpp
@ -154,7 +154,10 @@ ModResult ExtBanManager::GetStatus(ExtBan::ActingBase* extban, User* user, Chann
 				continue;
 		}

-		return extban->IsMatch(user, channel, xbvalue) != inverted ? MOD_RES_DENY : MOD_RES_PASSTHRU;
+		// For a non-inverted (regular) extban we want to match but for an
+		// inverted extban we want to not match.
+		if (extban->IsMatch(user, channel, xbvalue) != inverted)
+			return MOD_RES_DENY;
 	}
 	return MOD_RES_PASSTHRU;
 }
--- a/modules/core/core_info/core_info.cpp
+++ b/modules/core/core_info/core_info.cpp
@ -73,6 +73,7 @@ private:
 	CommandTime cmdtime;
 	ISupportManager isupport;
 	CommandVersion cmdversion;
+	Numeric::Numeric numeric003;
 	Numeric::Numeric numeric004;

 	/** Returns a list of user or channel mode characters.
@ -119,8 +120,11 @@ public:
 		, cmdtime(this)
 		, isupport(this)
 		, cmdversion(this, isupport)
+		, numeric003(RPL_CREATED)
 		, numeric004(RPL_MYINFO)
 	{
+		numeric003.push(Time::ToString(ServerInstance->StartTime, "This server was created on %d %b %Y at %H:%M:%S", true));
+
 		numeric004.push(ServerInstance->Config->GetServerName());
 		numeric004.push(INSPIRCD_BRANCH);
 	}
@ -186,7 +190,7 @@ public:
 	{
 		user->WriteNumeric(RPL_WELCOME, FMT::format("Welcome to the {} IRC Network {}", ServerInstance->Config->Network, user->GetRealMask()));
 		user->WriteNumeric(RPL_YOURHOST, FMT::format("Your host is {}, running version {}", ServerInstance->Config->GetServerName(), INSPIRCD_BRANCH));
-		user->WriteNumeric(RPL_CREATED, Time::ToString(ServerInstance->StartTime, "This server was created %H:%M:%S %b %d %Y"));
+		user->WriteNumeric(numeric003);
 		user->WriteNumeric(numeric004);
 		isupport.SendTo(user);

--- a/modules/core/core_who.cpp
+++ b/modules/core/core_who.cpp
@ -1,6 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
+ *   Copyright (C) 2024 Glen Miner <shaggie76@gmail.com>
 *   Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com>
 *   Copyright (C) 2018 Adam <Adam@anope.org>
 *   Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services>
@ -445,7 +446,7 @@ void CommandWho::WhoUsers(LocalUser* source, const std::vector<std::string>& par
 		User* user = GetUser(iter);

 		// Only show users in response to a fuzzy WHO if we can see them normally.
-		bool can_see_normally = user == source || source->SharesChannelWith(user) || !user->IsModeSet(invisiblemode);
+		bool can_see_normally = user == source || !user->IsModeSet(invisiblemode) || source->SharesChannelWith(user);
 		if (data.fuzzy_match && !can_see_normally && !source_has_users_auspex)
 			continue;

--- a/modules/core/core_whois.cpp
+++ b/modules/core/core_whois.cpp
@ -2,7 +2,7 @@
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2018 Dylan Frank <b00mx0r@aureus.pw>
- *   Copyright (C) 2017-2023 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2017-2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
 *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
--- a/modules/extra/pgsql.cpp
+++ b/modules/extra/pgsql.cpp
@ -1,6 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
+ *   Copyright (C) 2024 Larry Williamson <l422y@l422y.com>
 *   Copyright (C) 2015 Daniel Vassdal <shutter@canternet.org>
 *   Copyright (C) 2013, 2016-2017, 2019-2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2012-2015 Attila Molnar <attilamolnar@hush.com>
@ -177,7 +178,8 @@ public:
 		if (currentrow >= PQntuples(res))
 			return false;
 		int ncols = PQnfields(res);
-
+		
+		result.clear();
 		for(int i = 0; i < ncols; i++)
 		{
 			result.push_back(GetValue(currentrow, i));
--- a/modules/httpd_stats.cpp
+++ b/modules/httpd_stats.cpp
@ -73,7 +73,7 @@ namespace Stats
 				// Base64 encode the entire string and wrap it in a CDATA.
 				ret.clear();
 				ret += "<![CDATA[";
-				ret += Base64::Encode(str);
+				ret += Base64::Encode(str, nullptr, '=');
 				ret += "]]>";
 				break;
 			}
--- a/modules/ojoin.cpp
+++ b/modules/ojoin.cpp
@ -1,7 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
- *   Copyright (C) 2019-2023 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2019-2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
 *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
@ -115,7 +115,7 @@ public:

 	ModuleOjoin()
 		: Module(VF_VENDOR, "Adds the /OJOIN command which allows server operators to join a channel and receive the server operator-only Y (official-join) channel prefix mode.")
-		, np(this, ServerInstance->Config->ConfValue("ojoin")->getCharacter("prefix"))
+		, np(this, ServerInstance->Config->ConfValue("ojoin")->getCharacter("prefix", '\0', true))
 		, mycommand(this, np)
 	{
 	}
--- a/modules/operprefix.cpp
+++ b/modules/operprefix.cpp
@ -1,7 +1,7 @@
 /*
 * InspIRCd -- Internet Relay Chat Daemon
 *
- *   Copyright (C) 2019-2022 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2019-2022, 2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com>
 *   Copyright (C) 2012 Robby <robby@chatbelgie.be>
 *   Copyright (C) 2009-2010 Craig Edwards <brain@inspircd.org>
@ -38,7 +38,7 @@ public:
 	OperPrefixMode(Module* Creator)
 		: PrefixMode(Creator, "operprefix", 'y', OPERPREFIX_VALUE)
 	{
-		prefix = ServerInstance->Config->ConfValue("operprefix")->getCharacter("prefix", '!');
+		prefix = ServerInstance->Config->ConfValue("operprefix")->getCharacter("prefix", '!', true);
 		ranktoset = ranktounset = std::numeric_limits<ModeHandler::Rank>::max();
 	}
 };
--- a/modules/websocket.cpp
+++ b/modules/websocket.cpp
@ -21,9 +21,11 @@


 #include "inspircd.h"
+#include "extension.h"
 #include "iohook.h"
 #include "modules/hash.h"
 #include "modules/isupport.h"
+#include "modules/whois.h"
 #include "utility/string.h"

 #define UTF_CPP_CPLUSPLUS 199711L
@ -32,7 +34,31 @@
 static constexpr char MagicGUID[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 static constexpr char newline[] = "\r\n";
 static constexpr char whitespace[] = " \t";
-static dynamic_reference_nocheck<HashProvider>* sha1;
+
+struct SharedData final
+{
+	// An extension that stores the value of the Origin header.
+	StringExtItem origin;
+
+	// An extension that stores the real hostname for proxied hosts.
+	StringExtItem realhost;
+
+	// An extension that stores the real IP for proxied hosts.
+	StringExtItem realip;
+
+	// A reference to the SHA-1 provider.
+	dynamic_reference_nocheck<HashProvider> sha1;
+
+	SharedData(Module* mod)
+		: origin(mod, "websocket-origin", ExtensionType::USER, true)
+		, realhost(mod, "websocket-realhost", ExtensionType::USER, true)
+		, realip(mod, "websocket-realip", ExtensionType::USER, true)
+		, sha1(mod, "hash/sha1")
+	{
+	}
+};
+
+static SharedData* g_data;

 struct WebSocketConfig final
 {
@ -394,6 +420,10 @@ class WebSocketHook final
 		if (reqend == std::string::npos)
 			return 0;

+		LocalUser* luser = nullptr;
+		if (sock->type == StreamSocket::SS_USER)
+			luser = static_cast<UserIOHandler*>(sock)->user;
+
 		bool allowedorigin = false;
 		HTTPHeaderFinder originheader;
 		if (originheader.Find(recvq, "Origin:", 7, reqend))
@ -404,6 +434,8 @@ class WebSocketHook final
 				if (InspIRCd::Match(origin, cfgorigin, ascii_case_insensitive_map))
 				{
 					allowedorigin = true;
+					if (luser)
+						g_data->origin.Set(luser, origin);
 					break;
 				}
 			}
@ -425,9 +457,8 @@ class WebSocketHook final
 			return -1;
 		}

-		if (!config.proxyranges.empty() && sock->type == StreamSocket::SS_USER)
+		if (!config.proxyranges.empty() && luser)
 		{
-			LocalUser* luser = static_cast<UserIOHandler*>(sock)->user;
 			irc::sockets::sockaddrs realsa(luser->client_sa);

 			HTTPHeaderFinder proxyheader;
@ -453,7 +484,11 @@ class WebSocketHook final
 				{
 					// Give the user their real IP address.
 					if (realsa != luser->client_sa)
+					{
+						g_data->realhost.Set(luser, luser->GetRealHost());
+						g_data->realip.Set(luser, luser->GetAddress());
 						luser->ChangeRemoteAddress(realsa);
+					}

 					// Error if changing their IP gets them banned.
 					if (luser->quitting)
@ -506,7 +541,7 @@ class WebSocketHook final
 			return -1;
 		}

-		if (!*sha1)
+		if (!*g_data->sha1)
 		{
 			FailHandshake(sock, "HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n", "WebSocket: SHA-1 provider missing");
 			return -1;
@ -518,7 +553,7 @@ class WebSocketHook final
 		key.append(MagicGUID);

 		std::string reply = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ";
-		reply.append(Base64::Encode((*sha1)->GenerateRaw(key), nullptr, '=')).append(newline);
+		reply.append(Base64::Encode((*g_data->sha1)->GenerateRaw(key), nullptr, '=')).append(newline);
 		if (!selectedproto.empty())
 			reply.append("Sec-WebSocket-Protocol: ").append(selectedproto).append(newline);
 		reply.append(newline);
@ -637,20 +672,22 @@ void WebSocketHookProvider::OnAccept(StreamSocket* sock, const irc::sockets::soc

 class ModuleWebSocket final
 	: public Module
+	, public Whois::EventListener
 {
 private:
-	dynamic_reference_nocheck<HashProvider> hash;
 	std::shared_ptr<WebSocketHookProvider> hookprov;
 	ISupport::EventProvider isupportprov;
+	SharedData data;

 public:
 	ModuleWebSocket()
 		: Module(VF_VENDOR, "Allows WebSocket clients to connect to the IRC server.")
-		, hash(this, "hash/sha1")
+		, Whois::EventListener(this)
 		, hookprov(std::make_shared<WebSocketHookProvider>(this))
 		, isupportprov(this)
+		, data(this)
 	{
-		sha1 = &hash;
+		g_data = &data;
 	}

 	void ReadConfig(ConfigStatus& status) override
@ -715,6 +752,28 @@ public:
 		if ((user) && (user->eh.GetModHook(this)))
 			ServerInstance->Users.QuitUser(user, "WebSocket module unloading");
 	}
+
+	void OnWhois(Whois::Context& whois) override
+	{
+		if (!whois.GetSource()->HasPrivPermission("users/auspex"))
+			return; // Only visible to opers.
+
+		const auto* origin = data.origin.Get(whois.GetTarget());
+		const auto* realhost = data.realhost.Get(whois.GetTarget());
+		const auto* realip = data.realip.Get(whois.GetTarget());
+		if (!origin && !realhost && !realip)
+			return; // If these fields are not set then the client is not a WebSocket user.
+
+		// If either of these aren't set then the user's connection isn't proxied.
+		std::string missing = "*";
+		if (!realhost || !realip)
+			realhost = realip = &missing;
+
+		if (origin)
+			whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected from the " + *origin + " WebSocket origin");
+		else
+			whois.SendLine(RPL_WHOISGATEWAY, *realhost, *realip, "is connected from a non-web WebSocket origin");
+	}
 };

 MODULE_INIT(ModuleWebSocket)
--- a/src/inspircd.cpp
+++ b/src/inspircd.cpp
@ -503,6 +503,9 @@ InspIRCd::InspIRCd(int argc, char** argv)
 		Exit(EXIT_FAILURE);
 	}

+	// We only do this on boot because we might not be able to after dropping root.
+	WritePID();
+
 	// If we don't have a SID, generate one based on the server name and the server description
 	if (Config->ServerId.empty())
 		Config->ServerId = UIDGenerator::GenerateSID(Config->ServerName, Config->ServerDesc);
@ -590,7 +593,6 @@ InspIRCd::InspIRCd(int argc, char** argv)
 	QueryPerformanceFrequency(&this->Stats.BootCPU);
 #endif

-	WritePID();
 	DropRoot();

 	Logs.Normal("STARTUP", "Startup complete as '{}'[{}], {} max open sockets", Config->ServerName,
--- a/src/logging.cpp
+++ b/src/logging.cpp
@ -224,7 +224,7 @@ void Log::Manager::OpenLogs(bool requiremethods)
 	{
 		const auto* option = ServerInstance->Config->CommandLine.forceprotodebug ? "--protocoldebug" : "--debug";
 		Normal("LOG", "Not opening loggers because we were started with {}", option);
-		CheckRawLog();
+		CheckLevel();
 		return;
 	}

@ -232,7 +232,7 @@ void Log::Manager::OpenLogs(bool requiremethods)
 	if (!ServerInstance->Config->CommandLine.writelog)
 	{
 		Normal("LOG", "Not opening loggers because we were started with --nolog");
-		CheckRawLog();
+		CheckLevel();
 		return;
 	}

@ -291,7 +291,7 @@ void Log::Manager::OpenLogs(bool requiremethods)
 		cache.shrink_to_fit();
 		caching = false;
 	}
-	CheckRawLog();
+	CheckLevel();
 }

 void Log::Manager::RegisterServices()
@ -310,12 +310,20 @@ void Log::Manager::UnloadEngine(const Engine* engine)
 	Normal("LOG", "The {} log engine is unloading; removed {}/{} loggers.", engine->name.c_str(), logger_count - loggers.size(), logger_count);
 }

-void Log::Manager::CheckRawLog()
+void Log::Manager::CheckLevel()
 {
 	// There might be a logger not from the config so we need to check this outside of the creation loop.
-	ServerInstance->Config->RawLog = std::any_of(loggers.begin(), loggers.end(), [](const auto& logger) {
-		return logger.level >= Level::RAWIO;
-	});
+	auto newmaxlevel = Level::LOWEST;
+	for (const auto& logger : loggers)
+	{
+		if (logger.level > newmaxlevel)
+			newmaxlevel = logger.level;
+	}
+
+	std::swap(maxlevel, newmaxlevel);
+	ServerInstance->Config->RawLog = (newmaxlevel >= Level::RAWIO);
+
+	Debug("LOG", "Changed maximum log level from {} to {}", LevelToString(newmaxlevel), LevelToString(maxlevel));
 }

 void Log::Manager::Write(Level level, const std::string& type, const std::string& message)
@ -323,6 +331,9 @@ void Log::Manager::Write(Level level, const std::string& type, const std::string
 	if (logging)
 		return; // Avoid log loops.

+	if (maxlevel < level && !caching)
+		return; // No loggers care about this message.
+
 	logging = true;
 	time_t time = ServerInstance->Time();
 	for (auto& logger : loggers)
--- a/src/socketengine.cpp
+++ b/src/socketengine.cpp
@ -2,7 +2,7 @@
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2021 Dominic Hamon
- *   Copyright (C) 2017-2018, 2021-2023 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2017-2018, 2021-2024 Sadie Powell <sadie@witchery.services>
 *   Copyright (C) 2017 Robin Burchell <robin+git@viroteck.net>
 *   Copyright (C) 2013-2014 Adam <Adam@anope.org>
 *   Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com>
--- a/vendor/README.md
+++ b/vendor/README.md
@ -18,7 +18,7 @@ This directory contains vendored dependencies that are shipped with InspIRCd to

 **License** &mdash; MIT License

-**Version** &mdash; 11.0.2
+**Version** &mdash; 11.1.1

 **Website** &mdash; [https://github.com/fmtlib/fmt/](https://github.com/fmtlib/fmt/)

@ -58,6 +58,6 @@ This directory contains vendored dependencies that are shipped with InspIRCd to

 **License** &mdash; Boost Software License

-**Version** &mdash; v4.0.5
+**Version** &mdash; v4.0.6

 **Website** &mdash; [https://github.com/nemtrif/utfcpp](https://github.com/nemtrif/utfcpp)
--- a/vendor/fmt/args.h
+++ b/vendor/fmt/args.h
@ -17,7 +17,6 @@
 #include "format.h"  // std_string_view

 FMT_BEGIN_NAMESPACE
-
 namespace detail {

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

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

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

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

  friend class basic_format_args<Context>;

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

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

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

 public:
  constexpr dynamic_format_arg_store() = default;

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

  /// Reserves space to store at least `new_cap` arguments including
  /// `new_cap_named` named arguments.
  void reserve(size_t new_cap, size_t new_cap_named) {
    FMT_ASSERT(new_cap >= new_cap_named,
-               "Set of arguments includes set of named arguments");
+               "set of arguments includes set of named arguments");
    data_.reserve(new_cap);
    named_info_.reserve(new_cap_named);
  }
+
+  /// Returns the number of elements in the store.
+  size_t size() const noexcept { return data_.size(); }
 };

 FMT_END_NAMESPACE
--- a/vendor/fmt/base.h
+++ b/vendor/fmt/base.h
--- a/vendor/fmt/chrono.h
+++ b/vendor/fmt/chrono.h
--- a/vendor/fmt/color.h
+++ b/vendor/fmt/color.h
@ -330,7 +330,7 @@ FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
 namespace detail {

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

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

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

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

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

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

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

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

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

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

 namespace detail {

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

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

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

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

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

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

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

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

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

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

 template <typename S, typename... Args,
          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 void print(std::FILE* f, const S& fmt, const Args&... args) {
-  memory_buffer buffer;
-  fmt::format_to(std::back_inserter(buffer), fmt, args...);
-  detail::print(f, {buffer.data(), buffer.size()});
+  auto buf = memory_buffer();
+  fmt::format_to(appender(buf), fmt, args...);
+  detail::print(f, {buf.data(), buf.size()});
 }

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

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

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

 #include "format.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 namespace detail {

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

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

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

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

--- a/vendor/fmt/format.cc
+++ b/vendor/fmt/format.cc
@ -15,7 +15,8 @@ template FMT_API auto dragonbox::to_decimal(float x) noexcept
 template FMT_API auto dragonbox::to_decimal(double x) noexcept
    -> dragonbox::decimal_fp<double>;

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

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

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

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

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

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

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

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

  friend class file;

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

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

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

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

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

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

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

  FMT_API auto descriptor() const -> int;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

--- a/vendor/fmt/ostream.h
+++ b/vendor/fmt/ostream.h
@ -22,6 +22,14 @@

 #include "chrono.h"  // formatbuf

+#ifdef _MSVC_STL_UPDATE
+#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
+#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
+#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
+#else
+#  define FMT_MSVC_STL_UPDATE 0
+#endif
+
 FMT_BEGIN_NAMESPACE
 namespace detail {

@ -35,53 +43,18 @@ class file_access {
  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };

-#if FMT_MSC_VERSION
+#if FMT_MSVC_STL_UPDATE
 template class file_access<file_access_tag, std::filebuf,
                           &std::filebuf::_Myfile>;
 auto get_file(std::filebuf&) -> FILE*;
 #endif

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

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

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

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

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

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

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

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

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

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

 namespace detail {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    start = it;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  template <typename R, typename FormatContext>
  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto mapper = detail::range_mapper<buffered_context<Char>>();
    auto out = ctx.out();
    auto it = detail::range_begin(range);
    auto end = detail::range_end(range);
@ -498,7 +472,7 @@ struct range_formatter<
      if (i > 0) out = detail::copy<Char>(separator_, out);
      ctx.advance_to(out);
      auto&& item = *it;  // Need an lvalue
-      out = underlying_.format(mapper.map(item), ctx);
+      out = underlying_.format(item, ctx);
      ++i;
    }
    out = detail::copy<Char>(closing_bracket_, out);
@ -521,13 +495,8 @@ struct formatter<
            range_format_kind<R, Char>::value != range_format::disabled &&
            range_format_kind<R, Char>::value != range_format::map &&
            range_format_kind<R, Char>::value != range_format::string &&
-            range_format_kind<R, Char>::value != range_format::debug_string>
-// Workaround a bug in MSVC 2015 and earlier.
-#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
-        ,
-        detail::is_formattable_delayed<R, Char>
-#endif
-        >::value>> {
+            range_format_kind<R, Char>::value != range_format::debug_string>,
+        detail::is_formattable_delayed<R, Char>>::value>> {
 private:
  using range_type = detail::maybe_const_range<R>;
  range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
@ -543,8 +512,7 @@ struct formatter<
                                  detail::string_literal<Char, '}'>{});
  }

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

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

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

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

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

@ -673,22 +638,22 @@ struct formatter<join_view<It, Sentinel, Char>, Char> {
 #endif
  formatter<remove_cvref_t<value_type>, Char> value_formatter_;

-  using view_ref = conditional_t<std::is_copy_constructible<It>::value,
-                                 const join_view<It, Sentinel, Char>&,
-                                 join_view<It, Sentinel, Char>&&>;
+  using view = conditional_t<std::is_copy_constructible<It>::value,
+                             const join_view<It, Sentinel, Char>,
+                             join_view<It, Sentinel, Char>>;

 public:
  using nonlocking = void;

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

  template <typename FormatContext>
-  auto format(view_ref& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto it = std::forward<view_ref>(value).begin;
+  auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) {
+    using iter =
+        conditional_t<std::is_copy_constructible<view>::value, It, It&>;
+    iter it = value.begin;
    auto out = ctx.out();
    if (it == value.end) return out;
    out = value_formatter_.format(*it, ctx);
@ -703,39 +668,11 @@ struct formatter<join_view<It, Sentinel, Char>, Char> {
  }
 };

-/// Returns a view that formats the iterator range `[begin, end)` with elements
-/// separated by `sep`.
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
-  return {std::move(begin), end, sep};
-}
-
-/**
- * Returns a view that formats `range` with elements separated by `sep`.
- *
- * **Example**:
- *
- *     auto v = std::vector<int>{1, 2, 3};
- *     fmt::print("{}", fmt::join(v, ", "));
- *     // Output: 1, 2, 3
- *
- * `fmt::join` applies passed format specifiers to the range elements:
- *
- *     fmt::print("{:02}", fmt::join(v, ", "));
- *     // Output: 01, 02, 03
- */
-template <typename Range>
-auto join(Range&& r, string_view sep)
-    -> join_view<decltype(detail::range_begin(r)),
-                 decltype(detail::range_end(r))> {
-  return {detail::range_begin(r), detail::range_end(r), sep};
-}
-
-template <typename Char, typename... T> struct tuple_join_view : detail::view {
-  const std::tuple<T...>& tuple;
+template <typename Char, typename Tuple> struct tuple_join_view : detail::view {
+  const Tuple& tuple;
  basic_string_view<Char> sep;

-  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
+  tuple_join_view(const Tuple& t, basic_string_view<Char> s)
      : tuple(t), sep{s} {}
 };

@ -746,37 +683,36 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
 #  define FMT_TUPLE_JOIN_SPECIFIERS 0
 #endif

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

  template <typename FormatContext>
-  auto format(const tuple_join_view<Char, T...>& value,
+  auto format(const tuple_join_view<Char, Tuple>& value,
              FormatContext& ctx) const -> typename FormatContext::iterator {
-    return do_format(value, ctx,
-                     std::integral_constant<size_t, sizeof...(T)>());
+    return do_format(value, ctx, std::tuple_size<Tuple>());
  }

 private:
-  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
+  decltype(detail::tuple::get_formatters<Tuple, Char>(
+      detail::tuple_index_sequence<Tuple>())) formatters_;

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

-  template <typename ParseContext, size_t N>
-  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+  template <size_t N>
+  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
                              std::integral_constant<size_t, N>)
-      -> decltype(ctx.begin()) {
+      -> const Char* {
    auto end = ctx.begin();
 #if FMT_TUPLE_JOIN_SPECIFIERS
-    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
+    end = std::get<std::tuple_size<Tuple>::value - N>(formatters_).parse(ctx);
    if (N > 1) {
      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
      if (end != end1)
@ -787,18 +723,20 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
  }

  template <typename FormatContext>
-  auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
+  auto do_format(const tuple_join_view<Char, Tuple>&, FormatContext& ctx,
                 std::integral_constant<size_t, 0>) const ->
      typename FormatContext::iterator {
    return ctx.out();
  }

  template <typename FormatContext, size_t N>
-  auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+  auto do_format(const tuple_join_view<Char, Tuple>& value, FormatContext& ctx,
                 std::integral_constant<size_t, N>) const ->
      typename FormatContext::iterator {
-    auto out = std::get<sizeof...(T) - N>(formatters_)
-                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+    using std::get;
+    auto out =
+        std::get<std::tuple_size<Tuple>::value - N>(formatters_)
+            .format(get<std::tuple_size<Tuple>::value - N>(value.tuple), ctx);
    if (N <= 1) return out;
    out = detail::copy<Char>(value.sep, out);
    ctx.advance_to(out);
@ -846,6 +784,34 @@ struct formatter<

 FMT_BEGIN_EXPORT

+/// Returns a view that formats the iterator range `[begin, end)` with elements
+/// separated by `sep`.
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
+  return {std::move(begin), end, sep};
+}
+
+/**
+ * Returns a view that formats `range` with elements separated by `sep`.
+ *
+ * **Example**:
+ *
+ *     auto v = std::vector<int>{1, 2, 3};
+ *     fmt::print("{}", fmt::join(v, ", "));
+ *     // Output: 1, 2, 3
+ *
+ * `fmt::join` applies passed format specifiers to the range elements:
+ *
+ *     fmt::print("{:02}", fmt::join(v, ", "));
+ *     // Output: 01, 02, 03
+ */
+template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
+auto join(Range&& r, string_view sep)
+    -> join_view<decltype(detail::range_begin(r)),
+                 decltype(detail::range_end(r))> {
+  return {detail::range_begin(r), detail::range_end(r), sep};
+}
+
 /**
 * Returns an object that formats `std::tuple` with elements separated by `sep`.
 *
@ -855,9 +821,9 @@ FMT_BEGIN_EXPORT
 *     fmt::print("{}", fmt::join(t, ", "));
 *     // Output: 1, a
 */
-template <typename... T>
-FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
-    -> tuple_join_view<char, T...> {
+template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
+FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep)
+    -> tuple_join_view<char, Tuple> {
  return {tuple, sep};
 }

--- a/vendor/fmt/std.h
+++ b/vendor/fmt/std.h
@ -17,6 +17,7 @@
 #  include <complex>
 #  include <cstdlib>
 #  include <exception>
+#  include <functional>
 #  include <memory>
 #  include <thread>
 #  include <type_traits>
@ -26,7 +27,8 @@

 // Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
 #  if FMT_CPLUSPLUS >= 201703L
-#    if FMT_HAS_INCLUDE(<filesystem>)
+#    if FMT_HAS_INCLUDE(<filesystem>) && \
+        (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)
 #      include <filesystem>
 #    endif
 #    if FMT_HAS_INCLUDE(<variant>)
@ -122,14 +124,16 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
 public:
  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 template <typename It, typename Sentinel>
 auto join(It begin, Sentinel end, wstring_view sep)
@ -105,9 +140,9 @@ auto join(It begin, Sentinel end, wstring_view sep)
  return {begin, end, sep};
 }

-template <typename Range>
+template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
 auto join(Range&& range, wstring_view sep)
-    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
                 wchar_t> {
  return join(std::begin(range), std::end(range), sep);
 }
@ -118,19 +153,19 @@ auto join(std::initializer_list<T> list, wstring_view sep)
  return join(std::begin(list), std::end(list), sep);
 }

-template <typename... T>
-auto join(const std::tuple<T...>& tuple, basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, T...> {
+template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
+auto join(const Tuple& tuple, basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, Tuple> {
  return {tuple, sep};
 }

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

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

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

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

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

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

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

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

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

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

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

+inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
+  auto buffer = basic_memory_buffer<wchar_t>();
+  detail::vformat_to(buffer, fmt, args);
+  detail::write_buffer(os, buffer);
+}
+
+template <typename... T>
+void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
+}
+
+template <typename... T>
+void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
+  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
 /// Converts `value` to `std::wstring` using the default format for type `T`.
 template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
  return format(FMT_STRING(L"{}"), value);
--- a/vendor/utfcpp/core.h
+++ b/vendor/utfcpp/core.h
@ -215,7 +215,7 @@ namespace internal

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

-        code_point += (*it) & 0x3f;
+        code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f));

        return UTF8_OK;
    }
@ -234,11 +234,11 @@ namespace internal

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

-        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
+        code_point = static_cast<utfchar32_t>(code_point + ((utf8::internal::mask8(*it) << 6) & 0xfff));

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

-        code_point += (*it) & 0x3f;
+        code_point = static_cast<utfchar32_t>(code_point + ((*it) & 0x3f));

        return UTF8_OK;
    }
@ -327,7 +327,7 @@ namespace internal
            else if (is_lead_surrogate(first_word)) {
                const utfchar16_t second_word = *it++;
                if (is_trail_surrogate(second_word)) {
-                    code_point = (first_word << 10) + second_word + SURROGATE_OFFSET;
+                    code_point = static_cast<utfchar32_t>(first_word << 10) + second_word + SURROGATE_OFFSET;
                    return UTF8_OK;
                } else 
                    err = INCOMPLETE_SEQUENCE; 
--- a/vendor/utfcpp/unchecked.h
+++ b/vendor/utfcpp/unchecked.h
@ -115,15 +115,15 @@ namespace utf8
                    ++it; 
                    cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
                    ++it;
-                    cp += (*it) & 0x3f;
+                    cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f));
                    break;
                case 4:
                    ++it;
                    cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);                
                    ++it;
-                    cp += (utf8::internal::mask8(*it) << 6) & 0xfff;
+                    cp = static_cast<utfchar32_t>(cp + ((utf8::internal::mask8(*it) << 6) & 0xfff));
                    ++it;
-                    cp += (*it) & 0x3f; 
+                    cp = static_cast<utfchar32_t>(cp + ((*it) & 0x3f)); 
                    break;
            }
            ++it;