From da3b5b2131d2b4ff5cb127e92090fca568376835 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Wed, 24 May 2023 10:28:49 +1200
Subject: in-progress: Config refactor started, changed all existing keybind
 command args and added in the new files, still many errors

---
 commands.cpp            |   184 +
 commands.h              |    73 +
 config                  |    15 +
 config.cpp              |   423 +-
 config.h                |    85 +-
 error.h                 |    10 +-
 include/toml++/toml.hpp | 17257 ----------------------------------------------
 keybinds.cpp            |    45 +
 keybinds.h              |    19 +
 main.cpp                |    80 +-
 makefile                |     6 +-
 old.config.cpp          |   364 +
 old.config.h            |    93 +
 13 files changed, 987 insertions(+), 17667 deletions(-)
 create mode 100644 commands.cpp
 create mode 100644 commands.h
 create mode 100644 config
 delete mode 100644 include/toml++/toml.hpp
 create mode 100644 keybinds.cpp
 create mode 100644 keybinds.h
 create mode 100644 old.config.cpp
 create mode 100644 old.config.h

diff --git a/commands.cpp b/commands.cpp
new file mode 100644
index 0000000..3e78463
--- /dev/null
+++ b/commands.cpp
@@ -0,0 +1,184 @@
+#include "commands.h"
+#include "error.h"
+
+#include <cctype>
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+#include <regex>
+#include <cstring>
+
+using std::cout, std::endl, std::string, std::vector, std::tolower;
+
+const void CommandsModule::printHello(const CommandArg* argv)
+{
+	cout << "Hello" << endl;
+}
+
+const void CommandsModule::echo(const CommandArg* argv)
+{
+	cout << "Echo: '" << argv[0].str << '\'' << endl;
+}
+
+CommandsModule::CommandsModule()
+{
+	addCommand("printHello", &CommandsModule::printHello, 0, {}, this);
+	CommandArgType* args0 = new CommandArgType[1];
+	args0[0] = STR_REST;
+	addCommand("echo", &CommandsModule::echo, 1, args0, this);
+}
+CommandsModule::~CommandsModule()
+{
+	for(Command c : commandList)
+	{
+		// This is probably needed but its not working
+		//if(c.argc > 0)
+			//delete[] c.argTypes;
+	}
+}
+
+void CommandsModule::addCommand(Command c)
+{
+	if(lookupCommand(c.name) != nullptr)
+	{
+		cout << "Duplicate command: " << c.name << endl;
+	}
+	commandList.push_back(c);
+}
+
+struct NameMatches
+{
+	NameMatches(string s): s_{s} {}
+	bool operator()(Command c) { return (c.name == s_); }
+	string s_;        
+};
+
+Command* CommandsModule::lookupCommand(string name)
+{
+	auto elem = std::find_if(commandList.begin(), commandList.end(), NameMatches(name));
+	if (elem != commandList.end())
+	{
+		int i = elem - commandList.begin();
+		return &(commandList[i]);
+	}
+	else
+	{
+		return nullptr;
+	}
+}
+
+vector<string> CommandsModule::splitCommand(string command)
+{
+	vector<string> v;
+	string regexString = "((?:\"[^\"\n]+\")|(?:'[^'\n]+')|(?:[^ \n]+))+";
+	std::regex regex(regexString, std::regex_constants::_S_icase);
+	auto begin = std::sregex_iterator(command.begin(), command.end(), regex);
+	auto end = std::sregex_iterator();
+	for (std::sregex_iterator i = begin; i != end; i++)
+	{
+		std::smatch match = *i;
+		std::string str = match.str();
+		if(str[0] == '\'' || str[0] == '"')
+			str = str.substr(1, str.size() - 2);
+		v.push_back(str);
+	}
+	return v;
+}
+
+template <typename T>
+std::basic_string<T> lowercase(const std::basic_string<T>& s)
+{
+    std::basic_string<T> s2 = s;
+    std::transform(s2.begin(), s2.end(), s2.begin(), [](unsigned char c){ return std::tolower(c); });
+    return s2;
+}
+
+CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandArgType* argTypes, const int argc)
+{
+	CommandArg* args = new CommandArg[argc];
+	for(int i = 1; i < argc + 1; i++)
+	{
+		switch(argTypes[i-1])
+		{
+			case STR: args[i-1].str = (char*)split[i].c_str(); break;
+			case NUM: args[i-1].num = std::stoi(split[i]); break;
+			case DIR: args[i-1].dir = LEFT; break;
+			case STR_REST:
+			{
+				string rest = "";
+				for(int j = i; j < split.size(); j++)
+				{
+					rest += split[j];
+					if(j != split.size() - 1)
+						rest += " ";
+				}
+				args[i-1].str = new char[rest.size()];
+				strcpy(args[i-1].str, rest.c_str());
+				return args;
+			}
+			case NUM_ARR_REST:
+			{
+				int* rest = new int[split.size() - i];
+				for(int j = 0; j < split.size() - i; j++)
+				{
+					rest[j] = std::stoi(split[j + i]);
+				}
+				args[i-1].numArr = {rest, (int) split.size() - i};
+				return args;
+			}
+			default: cout << "UH OH SOMETHING IS VERY WRONG" << endl;
+		}
+	}
+	return args;
+}
+
+void CommandsModule::runCommand(string command)
+{
+	vector<string> split = splitCommand(command);
+	Command* cmd = lookupCommand(split[0]);
+	if(cmd == nullptr)
+		throw Err(CMD_ERR_NOT_FOUND, split[0] + " is not a valid command name");
+	if(cmd->argc > split.size() - 1)
+		throw Err(CMD_ERR_WRONG_ARGS, command + " is the wrong args");
+	CommandArg* args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	try
+	{
+		cmd->func(*cmd->module, args);
+	}
+	catch (Err e)
+	{
+		for(int i = 0; i < cmd->argc; i++)
+		{
+			if(cmd->argTypes[i] == STR_REST)
+				delete[] args[i].str;
+		}
+		delete[] args;
+		throw e;
+	}
+	for(int i = 0; i < cmd->argc; i++)
+	{
+		if(cmd->argTypes[i] == STR_REST)
+			delete[] args[i].str;
+	}
+	delete[] args;
+}
+
+Err CommandsModule::checkCommand(string command)
+{
+	vector<string> split = splitCommand(command);
+	Command* cmd = lookupCommand(split[0]);
+	if(cmd == nullptr)
+		return Err(CMD_ERR_NOT_FOUND, split[0] + " is not a valid command name");
+	if(cmd->argc > split.size())
+		return Err(CMD_ERR_WRONG_ARGS, command + " is the wrong args");
+	CommandArg* args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	for(int i = 0; i < cmd->argc; i++)
+	{
+		if(cmd->argTypes[i] == STR_REST || cmd->argTypes[i] == NUM_ARR_REST)
+			delete[] args[i].str;
+	}
+	delete[] args;
+	return Err(NOERR, "");
+}
diff --git a/commands.h b/commands.h
new file mode 100644
index 0000000..f9a0999
--- /dev/null
+++ b/commands.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "error.h"
+
+#include <vector>
+#include <string>
+#include <any>
+#include <functional>
+
+enum MoveDir
+{
+	UP,
+	RIGHT,
+	DOWN,
+	LEFT
+};
+enum CommandArgType
+{
+	STR,
+	NUM,
+	DIR,
+	STR_REST,
+	NUM_ARR_REST
+};
+
+struct NumArr
+{
+	int* arr;
+	int size;
+};
+typedef union
+{
+	char* str;
+	int num;
+	NumArr numArr;
+	MoveDir dir;
+} CommandArg;
+
+struct Command
+{
+	const std::string name;
+	const std::function<void(std::any&, const CommandArg* argv)> func;
+	const int argc;
+	CommandArgType* argTypes;
+	std::any* module;
+};
+class CommandsModule
+{
+	private:
+		std::vector<Command> commandList;
+		std::vector<std::string> splitCommand(std::string command);
+		CommandArg* getCommandArgs(std::vector<std::string>& args, const CommandArgType* argTypes, const int argc);
+		const void printHello(const CommandArg* argv);
+		const void echo(const CommandArg* argv);
+	public:   
+		CommandsModule();
+		~CommandsModule();
+		template <class T>
+		void addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, CommandArgType* argTypes, T* module);
+		void addCommand(Command c);
+		Command* lookupCommand(std::string name);
+		void runCommand(std::string command);
+		Err checkCommand(std::string command);
+};
+
+// YES I KNOW THIS IS BAD
+// but it needs to be done this way
+template <class T>
+void CommandsModule::addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, CommandArgType* argTypes, T* module)
+{
+	Command c = {name, (const void*(std::any::*)(const CommandArg* argv)) func, argc, argTypes, (std::any*)module};
+	addCommand(c);
+}
diff --git a/config b/config
new file mode 100644
index 0000000..3dcab8b
--- /dev/null
+++ b/config
@@ -0,0 +1,15 @@
+# This is a comment
+bind e exit
+bind q exit
+bind o echo test
+bind x spawn notify-send stuff
+bind a spawn xterm
+bind r reload
+spawn "notify-send test"
+spawn_once "notify-send once"
+gaps 10
+outergaps 10
+addworkspace "1: A" 1
+addworkspace "2: B" 1
+addworkspace "5: A" 2 1
+addworkspace "6: B" 2 1
\ No newline at end of file
diff --git a/config.cpp b/config.cpp
index 74ba0b0..101af24 100644
--- a/config.cpp
+++ b/config.cpp
@@ -1,349 +1,157 @@
 #include "config.h"
+#include "commands.h"
 
-#include "error.h"
-#include "toml++/toml.hpp"
-#include "util.h"
-
-#include <X11/X.h>
 #include <X11/Xlib.h>
 
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <ios>
 #include <string>
-#include <map>
+#include <vector>
+#include <sstream>
+#include <unistd.h>
+#include <fcntl.h>
 
 //Just for testing
 #include <iostream>
-#include <vector>
 
-using std::map, std::string, std::to_string;
+using std::string;
 
 // For testing
-using std::cout, std::endl, std::cerr;
-
-map<string, void(*) (const KeyArg arg)> funcNameMap = {
-	{"exit", exit},
-	{"spawn", spawn},
-	{"toggle", toggle},
-	{"kill", kill},
-	{"changeWS", changeWS},
-	{"wToWS", wToWS},
-	{"focChange", focChange},
-	{"wMove", wMove},
-	{"bashSpawn", bashSpawn},
-	{"reload", reload},
-	{"wsDump", wsDump},
-	{"nextMonitor", nextMonitor},
-};
-
+using std::cout, std::endl;
 
-Config::Config()
+const void Config::exit(const CommandArg* argv)
 {
+	cout << "exit called" << endl;
+}
+const void Config::spawn_once(const CommandArg* argv)
+{
+	if(loaded)
+		return;
+	if(fork() == 0)
+	{
+		int null = open("/dev/null", O_WRONLY);
+		dup2(null, 0);
+		dup2(null, 1);
+		dup2(null, 2);
+		system(argv[0].str);
+		exit(0);
+	}
 }
 
-string to_string(string s)
+const void Config::spawn(const CommandArg* argv)
 {
-	return s;
+	if(fork() == 0)
+	{
+		int null = open("/dev/null", O_WRONLY);
+		dup2(null, 0);
+		dup2(null, 1);
+		dup2(null, 2);
+		system(argv[0].str);
+		exit(0);
+	}
+}
+const void Config::changeWS(const CommandArg* argv)
+{
+	cout << "changeWS called" << endl;
+}
+const void Config::wToWS(const CommandArg* argv)
+{
+	cout << "wToWS called" << endl;
+}
+const void Config::focChange(const CommandArg* argv)
+{
+	cout << "focChange called" << endl;
 }
-string to_string(bool b)
+const void Config::reload(const CommandArg* argv)
 {
-	if(b)
-		return "true";
-	else
-		return "false";
+	cout << "Reloading config" << endl;
+	reloadFile();
 }
 
-template <typename T>
-T Config::getValue(string path, Err* err)
+const void Config::gapsCmd(const CommandArg* argv)
 {
-	std::optional<T> tblVal = tbl.at_path(path).value<T>();
-	if(tblVal)
-		return *tblVal;
-	else
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		T val = *defaults.at_path(path).value<T>();
-		err->errorMessage += "\n\tValue for " + path + " is invalid, using default (" + to_string(val) + ")";
-		return val;
-	}
+	gaps = argv[0].num;
 }
 
-void Config::loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err)
+const void Config::outerGapsCmd(const CommandArg* argv)
 {
-	if(!tbl["Workspaces"]["workspaceNames"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tworkspaceNames invalid array, using defaults";
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	workspaceNamesc = tbl["Workspaces"]["workspaceNames"].as_array()->size();
-	workspaceNames = new string[workspaceNamesc];
-	for(int i = 0; i < workspaceNamesc; i++)
-	{
-		auto element = tbl["Workspaces"]["workspaceNames"][i].value<string>();
-		if(element)
-			workspaceNames[i] = *element;
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\nelement " + to_string(i) + " in workspaceNames invalid, using defaults";
-			delete[] workspaceNames;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-	}
-	if(!tbl["Workspaces"]["screenPreferences"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nscreenPreferences invalid array, using default";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferencesc = tbl["Workspaces"]["screenPreferences"].as_array()->size();
-	if(screenPreferencesc != workspaceNamesc)
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nworkspaceNames and screenPreferences aren't the same length, using defaults";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferences = new int*[screenPreferencesc];
-	for(int i = 0; i < screenPreferencesc; i++)
-	{
-		if(!tbl["Workspaces"]["screenPreferences"][i].as_array())
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\telement " + to_string(i) + " in screenPreferences in invalid, using defaults";
-			delete[] workspaceNames;
-			for(int k = 0; k < i; k++)
-			{
-				delete[] screenPreferences[k];
-			}
-			delete[] screenPreferences;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-		int* wsScreens = new int[maxMonitors];
-		for(int j = 0; j < maxMonitors; j++)
-		{
-			if(tbl["Workspaces"]["screenPreferences"][i].as_array()->size() <= j)
-			{
-				wsScreens[j] = 0;
-				continue;
-			}
-			auto element = tbl["Workspaces"]["screenPreferences"][i][j].value<int>();
-			if(element)
-				wsScreens[j] = *element;
-			else
-			{
-				err->code = ERR_CFG_NON_FATAL;
-				err->errorMessage += "\telement " + to_string(i) + " " + to_string(j) + " in screenPreferences in invalid, using defaults";
-				delete[] workspaceNames;
-				for(int k = 0; k <= i; k++)
-				{
-					delete[] screenPreferences[k];
-				}
-				delete[] screenPreferences;
-				return loadWorkspaceArrays(defaults, defaults, err);
-			}
-		}
-		screenPreferences[i] = wsScreens;
-	}
+	outerGaps = argv[0].num;
 }
 
-void Config::loadStartupBash(toml::table tbl, toml::table defaults, Err* err)
+const void Config::logFileCmd(const CommandArg* argv)
 {
-	if(!tbl["Startup"]["startupBash"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tstartupBash array invalid, using default";
-		return loadStartupBash(defaults, defaults, err);
-	}
-	startupBashc = tbl["Startup"]["startupBash"].as_array()->size();
-	std::vector<string> startupBash;
-	for(int i = 0; i < startupBashc; i++)
-	{
-		auto element = tbl["Startup"]["startupBash"][i].value<string>();
-		if(element)
-			startupBash.push_back(*element);
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\n\tstartupBash element " + to_string(i) + " invalid, skipping";
-		}
-	}
-	startupBashc = startupBash.size();
-	this->startupBash = new string[startupBashc];
-	for(int i = 0; i < startupBash.size(); i++)
-	{
-		this->startupBash[i] = startupBash[i];
-	}
+	logFile = argv[0].str;
 }
 
-Err Config::reload()
+const void Config::addWorkspaceCmd(const CommandArg* argv)
 {
-	if(!loaded)
-		return {ERR_CFG_FATAL, "Path not set yet, call loadFromFile before reload"};
-	return loadFromFile(path);
+	int* prefs = new int[argv[1].numArr.size];
+	memcpy(prefs, argv[1].numArr.arr, argv[1].numArr.size * sizeof(int));
+	workspaces.push_back({argv[0].str, prefs, argv[1].numArr.size});
 }
 
-Err Config::loadFromFile(string path)
+Config::Config(CommandsModule& commandsModule)
+	: commandsModule(commandsModule)
 {
-	if(loaded)
-	{
-		free();
-	}
-	loaded = true;
-	this->path = path;
-	Err err;
-	err.code = NOERR;
-	err.errorMessage = "";
-	defaults = toml::parse_file("/etc/YATwm/config.toml");
-	try
-	{
-		tbl = toml::parse_file(path);
-	}
-	catch (const toml::parse_error& parseErr)
-	{
-		err.code = ERR_CFG_FATAL;
-		string description = (string) parseErr.description();
-		string startCol = std::to_string(parseErr.source().begin.column);
-		string startLine = std::to_string(parseErr.source().begin.line);
-		string endCol = std::to_string(parseErr.source().end.column);
-		string endLine = std::to_string(parseErr.source().end.line);
-		string pos =  "Line " + startLine;
-		string what = parseErr.what();
-		err.errorMessage += "\n\t" + description + "\t(" + pos + ")" + "\n\tUsing /etc/YATwm/config.toml instead";
-		tbl = defaults;
-	}
+	//Register commands for keybinds
+	CommandArgType* spawnArgs = new CommandArgType[1];
+	spawnArgs[0] = STR_REST;
+	commandsModule.addCommand("spawn", &Config::spawn, 1, spawnArgs, this);
+	commandsModule.addCommand("spawn_once", &Config::spawn_once, 1, spawnArgs, this);
+	commandsModule.addCommand("reload", &Config::reload, 0, {}, this);
+
+	//Register commands for config
+	CommandArgType* gapsArgs = new CommandArgType[1];
+	gapsArgs[0] = NUM;
+	commandsModule.addCommand("gaps", &Config::gapsCmd, 1, gapsArgs, this);
+	commandsModule.addCommand("outergaps", &Config::outerGapsCmd, 1, gapsArgs, this);
+	CommandArgType* logFileArgs = new CommandArgType[1];
+	logFileArgs[0] = STR_REST;
+	commandsModule.addCommand("logfile", &Config::logFileCmd, 1, logFileArgs, this);
+	CommandArgType* addWorkspaceArgs = new CommandArgType[2];
+	addWorkspaceArgs[0] = STR;
+	addWorkspaceArgs[1] = NUM_ARR_REST;
+	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, addWorkspaceArgs, this);
+}
 
-	//Startup
-	loadStartupBash(tbl, defaults, &err);
+void Config::reloadFile()
+{
+	if(!loaded)
+		return;
+	loadFromFile(file);
+}
 
-	//Main
-	gaps = getValue<int>("Main.gaps", &err);
-	outerGaps = getValue<int>("Main.outerGaps", &err);
-	logFile = getValue<string>("Main.logFile", &err);
+void Config::loadFromFile(string path)
+{
+	file = path;
+	//Set defaults
+	gaps = 3;
+	outerGaps = 3;
+	logFile = "/tmp/yatlog.txt";
 
-	//Workspaces
-	numWS = getValue<int>("Workspaces.numWS", &err);
-	maxMonitors = getValue<int>("Workspaces.maxMonitors", &err);
-	loadWorkspaceArrays(tbl, defaults, &err);
-	
-	//Keybinds
-	bool swapSuperAlt = getValue<bool>("Keybinds.swapSuperAlt", &err);
+	//Probably need something for workspaces and binds too...
 
-	toml::node_view<toml::node> bindsArr = tbl["Keybinds"]["key"];
-	if(!bindsArr.is_array())
+	string cmd;
+	int line = 0;
+	std::ifstream config(path);
+	while(getline(config, cmd))
 	{
-		err.code = ERR_CFG_NON_FATAL;
-		err.errorMessage += "\n\tBinds array not valid, using default";
-		bindsArr = defaults["Keybinds"]["key"];
-	}
-	std::vector<KeyBind> keyBinds;
-	bindsc = bindsArr.as_array()->size();
-	for(int i = 0; i < bindsc; i++)
-	{
-		KeyBind bind;
-		bind.modifiers = 0;
-		const std::optional<string> potentialBindString = bindsArr[i]["bind"].value<string>();
-		string bindString;
-		if(potentialBindString)
-			bindString = *potentialBindString;
-		else
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
+		if(cmd.at(0) == '#')
 			continue;
-		}
-		std::vector<string> keys = split(bindString, '+');
-		for(string key : keys)
-		{
-			if(key == "mod")
-			{
-				if(!swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "alt")
-			{
-				if(swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "shift")
-			{
-				bind.modifiers |= ShiftMask;
-			}
-			else if(key == "control")
-			{
-				bind.modifiers |= ControlMask;
-			}
-			else
-			{
-				bind.keysym = XStringToKeysym(key.c_str());
-				if(bind.keysym == NoSymbol)
-				{
-					err.code = ERR_CFG_NON_FATAL;
-					err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
-					continue;
-				}
-			}
-		}
-		std::optional<string> potentialFuncString = bindsArr[i]["func"].value<string>();
-		string funcString;
-		if(potentialFuncString)
-			funcString = *potentialFuncString;
-		else
+		try
 		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
+			commandsModule.runCommand(cmd);
 		}
-		if(funcNameMap.count(funcString) == 0)
+		catch (Err e)
 		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
+			cout << "Error in config (line " << line <<  "): " << e.code << endl;
+			cout << "\tMessage: " << e.message << endl;
 		}
-		void(* func) (const KeyArg arg) = funcNameMap.find(funcString)->second;
-		bind.func = func;
-
-		auto args = bindsArr[i]["args"];
-		if(args.is<int64_t>())
-		{
-			int num = *args.value<int>();
-			bind.args = {.num = num};
-		}
-		else if(args.is<string>())
-		{
-			string str = (string)*args.value<string>();
-			if(str == "Up")
-				bind.args = {.dir = Up};
-			else if (str == "Down")
-				bind.args = {.dir = Down};
-			else if (str == "Left")
-				bind.args = {.dir = Left};
-			else if (str == "Right")
-				bind.args = {.dir = Right};
-			else
-			{
-				bind.args = {.str = strdup(str.c_str())};
-			}
-		}
-		else
-		{
-			bind.args = {NULL};
-		}
-		keyBinds.push_back(bind);
+		line++;
 	}
-	bindsc = keyBinds.size();
-	binds = new KeyBind[bindsc];
-	for(int i = 0; i < bindsc; i++)
-	{
-		binds[i] = keyBinds[i];
-	}
-	if(err.code != NOERR)
-		err.errorMessage = err.errorMessage.substr(1);
-	return err;
+	loaded = true;
 }
 
 Config::~Config()
@@ -352,13 +160,10 @@ Config::~Config()
 }
 void Config::free()
 {
-	delete[] startupBash;
-	delete[] workspaceNames;
-	for(int i = 0; i < screenPreferencesc; i++)
+	if(!loaded)
+		return;
+	for(Workspace w : workspaces)
 	{
-		delete[] screenPreferences[i];
+		delete [] w.screenPreferences;
 	}
-	delete[] screenPreferences;
-	delete[] binds;
-	loaded = false;
 }
diff --git a/config.h b/config.h
index 31005e7..3956492 100644
--- a/config.h
+++ b/config.h
@@ -1,63 +1,30 @@
 #pragma once
 
-#include "error.h"
-
-#include <toml++/toml.hpp>
-
+#include "commands.h"
 #include <X11/X.h>
 #include <X11/keysym.h>
 
 #include <string>
 
-enum MoveDir
+struct Workspace
 {
-	Up,
-	Right,
-	Down,
-	Left
+	std::string name;
+	int* screenPreferences;
+	int screenPreferencesc;
 };
 
-typedef union
-{
-	char* str;
-	int num;
-	MoveDir dir;
-} KeyArg;
-
-struct KeyBind
-{
-	unsigned int modifiers;
-	KeySym keysym;
-	void(* func) (const KeyArg arg);
-	KeyArg args;
-};
-
-//Keybind commands
-#define KEYCOM(X) \
-	void X (const KeyArg arg)
-KEYCOM(exit);
-KEYCOM(spawn);
-KEYCOM(toggle);
-KEYCOM(kill);
-KEYCOM(changeWS);
-KEYCOM(wToWS);
-KEYCOM(focChange);
-KEYCOM(wMove);
-KEYCOM(bashSpawn);
-KEYCOM(reload);
-KEYCOM(wsDump);
-KEYCOM(nextMonitor);
+#define COMMAND(X) \
+	const void X (const CommandArg* argv)
 
 class Config
-{   
+{  
 	public:
-		Config();
+		Config(CommandsModule& commandsModule);
 		~Config();
 		void free();
 	
-		Err loadFromFile(std::string path);
-		Err reload();
-
+		void loadFromFile(std::string path);
+		void reloadFile();
 		// Startup
 		std::string* startupBash;
 		int startupBashc;
@@ -68,6 +35,7 @@ class Config
 		std::string logFile;
 
 		// Workspaces
+		std::vector<Workspace> workspaces;
 		int numWS;
 		std::string* workspaceNames;
 		int workspaceNamesc;
@@ -75,19 +43,22 @@ class Config
 		int** screenPreferences;
 		int screenPreferencesc;
 
-		// Keybinds
-		KeyBind* binds;
-		int bindsc;
+		// Config Commands
+		COMMAND(gapsCmd);
+		COMMAND(outerGapsCmd);
+		COMMAND(logFileCmd);
+		COMMAND(addWorkspaceCmd);
+
+		// Keybind Commands
+		COMMAND(exit);
+		COMMAND(spawn);
+		COMMAND(spawn_once);
+		COMMAND(changeWS);
+		COMMAND(wToWS);
+		COMMAND(focChange);
+		COMMAND(reload);
 	private:
-		template <typename T>
-		T getValue(std::string path, Err* err);
-
-		void loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err);
-		void loadStartupBash(toml::table tbl, toml::table defaults, Err* err);
-
-		toml::table tbl;
-		toml::table defaults;
-
+		CommandsModule& commandsModule;
 		bool loaded = false;
-		std::string path;
+		std::string file;
 };
diff --git a/error.h b/error.h
index b70085f..630fc7f 100644
--- a/error.h
+++ b/error.h
@@ -7,9 +7,13 @@ typedef unsigned int ErrCode;
 #define NOERR 0
 #define ERR_NON_FATAL 110
 #define ERR_FATAL 120
-#define ERR_CFG_NON_FATAL 210
-#define ERR_CFG_FATAL 220
-
+#define CFG_ERR_NON_FATAL 210
+#define CFG_ERR_KEYBIND 211
+#define CFG_ERR_FATAL 220
+#define CMD_ERR_NON_FATAL 310
+#define CMD_ERR_NOT_FOUND 311
+#define CMD_ERR_WRONG_ARGS 312
+#define CMD_ERR_FATAL 320
 struct Err
 {
 	ErrCode code;
diff --git a/include/toml++/toml.hpp b/include/toml++/toml.hpp
deleted file mode 100644
index 5e4c7f8..0000000
--- a/include/toml++/toml.hpp
+++ /dev/null
@@ -1,17257 +0,0 @@
-//----------------------------------------------------------------------------------------------------------------------
-//
-// toml++ v3.2.0
-// https://github.com/marzer/tomlplusplus
-// SPDX-License-Identifier: MIT
-//
-//----------------------------------------------------------------------------------------------------------------------
-//
-// -         THIS FILE WAS ASSEMBLED FROM MULTIPLE HEADER FILES BY A SCRIPT - PLEASE DON'T EDIT IT DIRECTLY            -
-//
-// If you wish to submit a contribution to toml++, hooray and thanks! Before you crack on, please be aware that this
-// file was assembled from a number of smaller files by a python script, and code contributions should not be made
-// against it directly. You should instead make your changes in the relevant source file(s). The file names of the files
-// that contributed to this header can be found at the beginnings and ends of the corresponding sections of this file.
-//
-//----------------------------------------------------------------------------------------------------------------------
-//
-// TOML Language Specifications:
-// latest:      https://github.com/toml-lang/toml/blob/master/README.md
-// v1.0.0:      https://toml.io/en/v1.0.0
-// v0.5.0:      https://toml.io/en/v0.5.0
-// changelog:   https://github.com/toml-lang/toml/blob/master/CHANGELOG.md
-//
-//----------------------------------------------------------------------------------------------------------------------
-//
-// MIT License
-//
-// Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-// documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-// Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-//----------------------------------------------------------------------------------------------------------------------
-#ifndef TOMLPLUSPLUS_H
-#define TOMLPLUSPLUS_H
-
-#define INCLUDE_TOMLPLUSPLUS_H // old guard name used pre-v3
-
-//********  impl/preprocessor.h  ***************************************************************************************
-
-#ifndef __cplusplus
-#error toml++ is a C++ library.
-#endif
-#ifdef _MSVC_LANG
-#define TOML_CPP _MSVC_LANG
-#else
-#define TOML_CPP __cplusplus
-#endif
-#if TOML_CPP >= 202002L
-#undef TOML_CPP
-#define TOML_CPP 20
-#elif TOML_CPP >= 201703L
-#undef TOML_CPP
-#define TOML_CPP 17
-#else
-#if TOML_CPP < 201103L
-#error toml++ requires C++17 or higher. For a pre-C++11 TOML library see https://github.com/ToruNiina/Boost.toml
-#elif TOML_CPP < 201703L
-#error toml++ requires C++17 or higher. For a C++11 TOML library see https://github.com/ToruNiina/toml11
-#endif
-#endif
-
-#ifdef __clang__
-#define TOML_CLANG __clang_major__
-#else
-#define TOML_CLANG 0
-#endif
-#ifdef __INTEL_COMPILER
-#define TOML_ICC __INTEL_COMPILER
-#ifdef __ICL
-#define TOML_ICC_CL TOML_ICC
-#else
-#define TOML_ICC_CL 0
-#endif
-#else
-#define TOML_ICC	0
-#define TOML_ICC_CL 0
-#endif
-#if defined(_MSC_VER) && !TOML_CLANG && !TOML_ICC
-#define TOML_MSVC _MSC_VER
-#else
-#define TOML_MSVC 0
-#endif
-#if defined(__GNUC__) && !TOML_CLANG && !TOML_ICC
-#define TOML_GCC __GNUC__
-#else
-#define TOML_GCC 0
-#endif
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__CYGWIN__)
-#define TOML_WINDOWS 1
-#else
-#define TOML_WINDOWS 0
-#endif
-#if defined(DOXYGEN) || defined(__DOXYGEN__) || defined(__POXY__) || defined(__poxy__)
-#define TOML_DOXYGEN 1
-#else
-#define TOML_DOXYGEN 0
-#endif
-#ifdef __INTELLISENSE__
-#define TOML_INTELLISENSE 1
-#else
-#define TOML_INTELLISENSE 0
-#endif
-
-// IA64
-#if defined(__ia64__) || defined(__ia64) || defined(_IA64) || defined(__IA64__) || defined(_M_IA64)
-#define TOML_ARCH_ITANIUM 1
-#else
-#define TOML_ARCH_ITANIUM 0
-#endif
-
-// AMD64
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
-#define TOML_ARCH_AMD64 1
-#else
-#define TOML_ARCH_AMD64 0
-#endif
-
-// 32-bit x86
-#if defined(__i386__) || defined(_M_IX86)
-#define TOML_ARCH_X86 1
-#else
-#define TOML_ARCH_X86 0
-#endif
-
-// ARM
-#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64) || defined(_M_ARM64) || defined(__ARM_64BIT_STATE)             \
-	|| defined(_M_ARM64EC)
-#define TOML_ARCH_ARM32 0
-#define TOML_ARCH_ARM64 1
-#define TOML_ARCH_ARM	1
-#elif defined(__arm__) || defined(_M_ARM) || defined(__ARM_32BIT_STATE)
-#define TOML_ARCH_ARM32 1
-#define TOML_ARCH_ARM64 0
-#define TOML_ARCH_ARM	1
-#else
-#define TOML_ARCH_ARM32 0
-#define TOML_ARCH_ARM64 0
-#define TOML_ARCH_ARM	0
-#endif
-
-// TOML_HAS_INCLUDE
-#ifdef __has_include
-#define TOML_HAS_INCLUDE(header) __has_include(header)
-#else
-#define TOML_HAS_INCLUDE(header) 0
-#endif
-
-#ifdef __has_builtin
-#define TOML_HAS_BUILTIN(name) __has_builtin(name)
-#else
-#define TOML_HAS_BUILTIN(name) 0
-#endif
-
-// TOML_HAS_FEATURE
-#ifdef __has_feature
-#define TOML_HAS_FEATURE(name) __has_feature(name)
-#else
-#define TOML_HAS_FEATURE(name) 0
-#endif
-
-// TOML_HAS_ATTR
-#ifdef __has_attribute
-#define TOML_HAS_ATTR(attr) __has_attribute(attr)
-#else
-#define TOML_HAS_ATTR(attr) 0
-#endif
-
-// TOML_HAS_CPP_ATTR
-#ifdef __has_cpp_attribute
-#define TOML_HAS_CPP_ATTR(attr) __has_cpp_attribute(attr)
-#else
-#define TOML_HAS_CPP_ATTR(attr) 0
-#endif
-
-// TOML_COMPILER_HAS_EXCEPTIONS
-#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) || defined(__cpp_exceptions)
-#define TOML_COMPILER_HAS_EXCEPTIONS 1
-#else
-#define TOML_COMPILER_HAS_EXCEPTIONS 0
-#endif
-
-// TOML_COMPILER_HAS_RTTI
-#if defined(_CPPRTTI) || defined(__GXX_RTTI) || TOML_HAS_FEATURE(cxx_rtti)
-#define TOML_COMPILER_HAS_RTTI 1
-#else
-#define TOML_COMPILER_HAS_RTTI 0
-#endif
-
-// TOML_ATTR (gnu attributes)
-#if TOML_CLANG || TOML_GCC || defined(__GNUC__)
-#define TOML_ATTR(...) __attribute__((__VA_ARGS__))
-#else
-#define TOML_ATTR(...)
-#endif
-
-// TOML_DECLSPEC (msvc attributes)
-#ifdef _MSC_VER
-#define TOML_DECLSPEC(...) __declspec(__VA_ARGS__)
-#else
-#define TOML_DECLSPEC(...)
-#endif
-
-// TOML_CONCAT
-#define TOML_CONCAT_1(x, y) x##y
-#define TOML_CONCAT(x, y)	TOML_CONCAT_1(x, y)
-
-// TOML_MAKE_STRING
-#define TOML_MAKE_STRING_1(s) #s
-#define TOML_MAKE_STRING(s)	  TOML_MAKE_STRING_1(s)
-
-// TOML_PRAGMA_XXXX (compiler-specific pragmas)
-#if TOML_CLANG
-#define TOML_PRAGMA_CLANG(decl) _Pragma(TOML_MAKE_STRING(clang decl))
-#else
-#define TOML_PRAGMA_CLANG(decl)
-#endif
-#if TOML_CLANG >= 9
-#define TOML_PRAGMA_CLANG_GE_9(decl) TOML_PRAGMA_CLANG(decl)
-#else
-#define TOML_PRAGMA_CLANG_GE_9(decl)
-#endif
-#if TOML_CLANG >= 10
-#define TOML_PRAGMA_CLANG_GE_10(decl) TOML_PRAGMA_CLANG(decl)
-#else
-#define TOML_PRAGMA_CLANG_GE_10(decl)
-#endif
-#if TOML_CLANG >= 11
-#define TOML_PRAGMA_CLANG_GE_11(decl) TOML_PRAGMA_CLANG(decl)
-#else
-#define TOML_PRAGMA_CLANG_GE_11(decl)
-#endif
-#if TOML_GCC
-#define TOML_PRAGMA_GCC(decl) _Pragma(TOML_MAKE_STRING(GCC decl))
-#else
-#define TOML_PRAGMA_GCC(decl)
-#endif
-#if TOML_MSVC
-#define TOML_PRAGMA_MSVC(...) __pragma(__VA_ARGS__)
-#else
-#define TOML_PRAGMA_MSVC(...)
-#endif
-#if TOML_ICC
-#define TOML_PRAGMA_ICC(...) __pragma(__VA_ARGS__)
-#else
-#define TOML_PRAGMA_ICC(...)
-#endif
-
-// TOML_ALWAYS_INLINE
-#ifdef _MSC_VER
-#define TOML_ALWAYS_INLINE __forceinline
-#elif TOML_GCC || TOML_CLANG || TOML_HAS_ATTR(__always_inline__)
-#define TOML_ALWAYS_INLINE                                                                                             \
-	TOML_ATTR(__always_inline__)                                                                                       \
-	inline
-#else
-#define TOML_ALWAYS_INLINE inline
-#endif
-
-// TOML_NEVER_INLINE
-#ifdef _MSC_VER
-#define TOML_NEVER_INLINE TOML_DECLSPEC(noinline)
-#elif TOML_GCC || TOML_CLANG || TOML_HAS_ATTR(__noinline__)
-#define TOML_NEVER_INLINE TOML_ATTR(__noinline__)
-#else
-#define TOML_NEVER_INLINE
-#endif
-
-// MSVC attributes
-#define TOML_ABSTRACT_INTERFACE TOML_DECLSPEC(novtable)
-#define TOML_EMPTY_BASES		TOML_DECLSPEC(empty_bases)
-
-// TOML_TRIVIAL_ABI
-#if TOML_CLANG || TOML_HAS_ATTR(__trivial_abi__)
-#define TOML_TRIVIAL_ABI TOML_ATTR(__trivial_abi__)
-#else
-#define TOML_TRIVIAL_ABI
-#endif
-
-// TOML_NODISCARD
-#if TOML_CPP >= 17 && TOML_HAS_CPP_ATTR(nodiscard) >= 201603
-#define TOML_NODISCARD [[nodiscard]]
-#elif TOML_CLANG || TOML_GCC || TOML_HAS_ATTR(__warn_unused_result__)
-#define TOML_NODISCARD TOML_ATTR(__warn_unused_result__)
-#else
-#define TOML_NODISCARD
-#endif
-
-// TOML_NODISCARD_CTOR
-#if TOML_CPP >= 17 && TOML_HAS_CPP_ATTR(nodiscard) >= 201907
-#define TOML_NODISCARD_CTOR [[nodiscard]]
-#else
-#define TOML_NODISCARD_CTOR
-#endif
-
-// pure + const
-// clang-format off
-#ifdef NDEBUG
-	#define TOML_PURE					TOML_DECLSPEC(noalias)	TOML_ATTR(__pure__)
-	#define TOML_CONST					TOML_DECLSPEC(noalias)	TOML_ATTR(__const__)
-	#define TOML_PURE_GETTER			TOML_NODISCARD						TOML_PURE
-	#define TOML_CONST_GETTER			TOML_NODISCARD						TOML_CONST
-	#define TOML_PURE_INLINE_GETTER		TOML_NODISCARD	TOML_ALWAYS_INLINE	TOML_PURE
-	#define TOML_CONST_INLINE_GETTER	TOML_NODISCARD	TOML_ALWAYS_INLINE	TOML_CONST
-#else
-	#define TOML_PURE
-	#define TOML_CONST
-	#define TOML_PURE_GETTER			TOML_NODISCARD
-	#define TOML_CONST_GETTER			TOML_NODISCARD
-	#define TOML_PURE_INLINE_GETTER		TOML_NODISCARD	TOML_ALWAYS_INLINE
-	#define TOML_CONST_INLINE_GETTER	TOML_NODISCARD	TOML_ALWAYS_INLINE
-#endif
-// clang-format on
-
-// TOML_ASSUME
-#ifdef _MSC_VER
-#define TOML_ASSUME(...) __assume(__VA_ARGS__)
-#elif TOML_ICC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_assume)
-#define TOML_ASSUME(...) __builtin_assume(__VA_ARGS__)
-#else
-#define TOML_ASSUME(...) static_assert(true)
-#endif
-
-// TOML_UNREACHABLE
-#ifdef _MSC_VER
-#define TOML_UNREACHABLE __assume(0)
-#elif TOML_ICC || TOML_CLANG || TOML_GCC || TOML_HAS_BUILTIN(__builtin_unreachable)
-#define TOML_UNREACHABLE __builtin_unreachable()
-#else
-#define TOML_UNREACHABLE static_assert(true)
-#endif
-
-// TOML_LIKELY
-#if TOML_CPP >= 20 && TOML_HAS_CPP_ATTR(likely) >= 201803
-#define TOML_LIKELY(...) (__VA_ARGS__) [[likely]]
-#define TOML_LIKELY_CASE [[likely]]
-#elif TOML_GCC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_expect)
-#define TOML_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1))
-#else
-#define TOML_LIKELY(...) (__VA_ARGS__)
-#endif
-#ifndef TOML_LIKELY_CASE
-#define TOML_LIKELY_CASE
-#endif
-
-// TOML_UNLIKELY
-#if TOML_CPP >= 20 && TOML_HAS_CPP_ATTR(unlikely) >= 201803
-#define TOML_UNLIKELY(...) (__VA_ARGS__) [[unlikely]]
-#define TOML_UNLIKELY_CASE [[unlikely]]
-#elif TOML_GCC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_expect)
-#define TOML_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0))
-#else
-#define TOML_UNLIKELY(...) (__VA_ARGS__)
-#endif
-#ifndef TOML_UNLIKELY_CASE
-#define TOML_UNLIKELY_CASE
-#endif
-
-// TOML_FLAGS_ENUM
-#if TOML_CLANG || TOML_HAS_ATTR(flag_enum)
-#define TOML_FLAGS_ENUM __attribute__((flag_enum))
-#else
-#define TOML_FLAGS_ENUM
-#endif
-
-// TOML_OPEN_ENUM + TOML_CLOSED_ENUM
-#if TOML_CLANG || TOML_HAS_ATTR(enum_extensibility)
-#define TOML_OPEN_ENUM	 __attribute__((enum_extensibility(open)))
-#define TOML_CLOSED_ENUM __attribute__((enum_extensibility(closed)))
-#else
-#define TOML_OPEN_ENUM
-#define TOML_CLOSED_ENUM
-#endif
-
-// TOML_OPEN_FLAGS_ENUM + TOML_CLOSED_FLAGS_ENUM
-#define TOML_OPEN_FLAGS_ENUM   TOML_OPEN_ENUM TOML_FLAGS_ENUM
-#define TOML_CLOSED_FLAGS_ENUM TOML_CLOSED_ENUM TOML_FLAGS_ENUM
-
-// TOML_MAKE_FLAGS
-#define TOML_MAKE_FLAGS_2(T, op, linkage)                                                                              \
-	TOML_CONST_INLINE_GETTER                                                                                           \
-	linkage constexpr T operator op(T lhs, T rhs) noexcept                                                             \
-	{                                                                                                                  \
-		using under = std::underlying_type_t<T>;                                                                       \
-		return static_cast<T>(static_cast<under>(lhs) op static_cast<under>(rhs));                                     \
-	}                                                                                                                  \
-                                                                                                                       \
-	linkage constexpr T& operator TOML_CONCAT(op, =)(T & lhs, T rhs) noexcept                                          \
-	{                                                                                                                  \
-		return lhs = (lhs op rhs);                                                                                     \
-	}                                                                                                                  \
-                                                                                                                       \
-	static_assert(true)
-#define TOML_MAKE_FLAGS_1(T, linkage)                                                                                  \
-	static_assert(std::is_enum_v<T>);                                                                                  \
-                                                                                                                       \
-	TOML_MAKE_FLAGS_2(T, &, linkage);                                                                                  \
-	TOML_MAKE_FLAGS_2(T, |, linkage);                                                                                  \
-	TOML_MAKE_FLAGS_2(T, ^, linkage);                                                                                  \
-                                                                                                                       \
-	TOML_CONST_INLINE_GETTER                                                                                           \
-	linkage constexpr T operator~(T val) noexcept                                                                      \
-	{                                                                                                                  \
-		using under = std::underlying_type_t<T>;                                                                       \
-		return static_cast<T>(~static_cast<under>(val));                                                               \
-	}                                                                                                                  \
-                                                                                                                       \
-	TOML_CONST_INLINE_GETTER                                                                                           \
-	linkage constexpr bool operator!(T val) noexcept                                                                   \
-	{                                                                                                                  \
-		using under = std::underlying_type_t<T>;                                                                       \
-		return !static_cast<under>(val);                                                                               \
-	}                                                                                                                  \
-                                                                                                                       \
-	static_assert(true)
-#define TOML_MAKE_FLAGS(T) TOML_MAKE_FLAGS_1(T, )
-
-#define TOML_UNUSED(...) static_cast<void>(__VA_ARGS__)
-
-#define TOML_DELETE_DEFAULTS(T)                                                                                        \
-	T(const T&)			   = delete;                                                                                   \
-	T(T&&)				   = delete;                                                                                   \
-	T& operator=(const T&) = delete;                                                                                   \
-	T& operator=(T&&)	   = delete
-
-#define TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...)                                                                  \
-	__VA_ARGS__ TOML_NODISCARD                                                                                         \
-	friend bool operator==(RHS rhs, LHS lhs) noexcept                                                                  \
-	{                                                                                                                  \
-		return lhs == rhs;                                                                                             \
-	}                                                                                                                  \
-	__VA_ARGS__ TOML_NODISCARD                                                                                         \
-	friend bool operator!=(LHS lhs, RHS rhs) noexcept                                                                  \
-	{                                                                                                                  \
-		return !(lhs == rhs);                                                                                          \
-	}                                                                                                                  \
-	__VA_ARGS__ TOML_NODISCARD                                                                                         \
-	friend bool operator!=(RHS rhs, LHS lhs) noexcept                                                                  \
-	{                                                                                                                  \
-		return !(lhs == rhs);                                                                                          \
-	}                                                                                                                  \
-	static_assert(true)
-
-#define TOML_EVAL_BOOL_1(T, F) T
-#define TOML_EVAL_BOOL_0(T, F) F
-
-#if !defined(__POXY__) && !defined(POXY_IMPLEMENTATION_DETAIL)
-#define POXY_IMPLEMENTATION_DETAIL(...) __VA_ARGS__
-#endif
-
-// COMPILER-SPECIFIC WARNING MANAGEMENT
-
-#if TOML_CLANG
-
-#define TOML_PUSH_WARNINGS                                                                                             \
-	TOML_PRAGMA_CLANG(diagnostic push)                                                                                 \
-	static_assert(true)
-
-#define TOML_DISABLE_SWITCH_WARNINGS                                                                                   \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wswitch")                                                                   \
-	static_assert(true)
-
-#define TOML_DISABLE_ARITHMETIC_WARNINGS                                                                               \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wfloat-equal")                                                              \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wdouble-promotion")                                                         \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wchar-subscripts")                                                          \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wshift-sign-overflow")                                                      \
-	static_assert(true)
-
-#define TOML_DISABLE_SPAM_WARNINGS                                                                                     \
-	TOML_PRAGMA_CLANG_GE_9(diagnostic ignored "-Wctad-maybe-unsupported")                                              \
-	TOML_PRAGMA_CLANG_GE_10(diagnostic ignored "-Wzero-as-null-pointer-constant")                                      \
-	TOML_PRAGMA_CLANG_GE_11(diagnostic ignored "-Wsuggest-destructor-override")                                        \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables")                                                             \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wweak-template-vtables")                                                    \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wdouble-promotion")                                                         \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wchar-subscripts")                                                          \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wmissing-field-initializers")                                               \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Wpadded")                                                                   \
-	static_assert(true)
-
-#define TOML_POP_WARNINGS                                                                                              \
-	TOML_PRAGMA_CLANG(diagnostic pop)                                                                                  \
-	static_assert(true)
-
-#define TOML_DISABLE_WARNINGS                                                                                          \
-	TOML_PRAGMA_CLANG(diagnostic push)                                                                                 \
-	TOML_PRAGMA_CLANG(diagnostic ignored "-Weverything")                                                               \
-	static_assert(true, "")
-
-#define TOML_ENABLE_WARNINGS                                                                                           \
-	TOML_PRAGMA_CLANG(diagnostic pop)                                                                                  \
-	static_assert(true)
-
-#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 1
-
-#elif TOML_MSVC
-
-#define TOML_PUSH_WARNINGS                                                                                             \
-	__pragma(warning(push))                                                                                            \
-	static_assert(true)
-
-#if TOML_HAS_INCLUDE(<CodeAnalysis / Warnings.h>)
-#pragma warning(push, 0)
-#include <CodeAnalysis/Warnings.h>
-#pragma warning(pop)
-#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS                                                                            \
-	__pragma(warning(disable : ALL_CODE_ANALYSIS_WARNINGS))                                                            \
-	static_assert(true)
-#else
-#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)
-#endif
-
-#define TOML_DISABLE_SWITCH_WARNINGS                                                                                   \
-	__pragma(warning(disable : 4061))                                                                                  \
-	__pragma(warning(disable : 4062))                                                                                  \
-	__pragma(warning(disable : 4063))                                                                                  \
-	__pragma(warning(disable : 5262))  /* switch-case implicit fallthrough (false-positive) */                         \
-	__pragma(warning(disable : 26819)) /* cg: unannotated fallthrough */                                               \
-	static_assert(true)
-
-#define TOML_DISABLE_SPAM_WARNINGS                                                                                     \
-	__pragma(warning(disable : 4127)) /* conditional expr is constant */                                               \
-	__pragma(warning(disable : 4324)) /* structure was padded due to alignment specifier */                            \
-	__pragma(warning(disable : 4348))                                                                                  \
-	__pragma(warning(disable : 4464)) /* relative include path contains '..' */                                        \
-	__pragma(warning(disable : 4505)) /* unreferenced local function removed */                                        \
-	__pragma(warning(disable : 4514)) /* unreferenced inline function has been removed */                              \
-	__pragma(warning(disable : 4582)) /* constructor is not implicitly called */                                       \
-	__pragma(warning(disable : 4619)) /*  there is no warning number 'XXXX' */                                         \
-	__pragma(warning(disable : 4623)) /* default constructor was implicitly defined as deleted */                      \
-	__pragma(warning(disable : 4625)) /* copy constructor was implicitly defined as deleted */                         \
-	__pragma(warning(disable : 4626)) /* assignment operator was implicitly defined as deleted */                      \
-	__pragma(warning(disable : 4710)) /* function not inlined */                                                       \
-	__pragma(warning(disable : 4711)) /* function selected for automatic expansion */                                  \
-	__pragma(warning(disable : 4820)) /* N bytes padding added */                                                      \
-	__pragma(warning(disable : 4946)) /* reinterpret_cast used between related classes */                              \
-	__pragma(warning(disable : 5026)) /* move constructor was implicitly defined as deleted	*/                         \
-	__pragma(warning(disable : 5027)) /* move assignment operator was implicitly defined as deleted	*/                 \
-	__pragma(warning(disable : 5039)) /* potentially throwing function passed to 'extern "C"' function */              \
-	__pragma(warning(disable : 5045)) /* Compiler will insert Spectre mitigation */                                    \
-	__pragma(warning(disable : 5264)) /* const variable is not used (false-positive) */                                \
-	__pragma(warning(disable : 26451))                                                                                 \
-	__pragma(warning(disable : 26490))                                                                                 \
-	__pragma(warning(disable : 26495))                                                                                 \
-	__pragma(warning(disable : 26812))                                                                                 \
-	__pragma(warning(disable : 26819))                                                                                 \
-	static_assert(true)
-
-#define TOML_DISABLE_ARITHMETIC_WARNINGS                                                                               \
-	__pragma(warning(disable : 4365)) /* argument signed/unsigned mismatch */                                          \
-	__pragma(warning(disable : 4738)) /* storing 32-bit float result in memory */                                      \
-	__pragma(warning(disable : 5219)) /* implicit conversion from integral to float */                                 \
-	static_assert(true)
-
-#define TOML_POP_WARNINGS                                                                                              \
-	__pragma(warning(pop))                                                                                             \
-	static_assert(true)
-
-#define TOML_DISABLE_WARNINGS                                                                                          \
-	__pragma(warning(push, 0))                                                                                         \
-	__pragma(warning(disable : 4348))                                                                                  \
-	__pragma(warning(disable : 4668))                                                                                  \
-	__pragma(warning(disable : 5105))                                                                                  \
-	__pragma(warning(disable : 5264))                                                                                  \
-	TOML_DISABLE_CODE_ANALYSIS_WARNINGS;                                                                               \
-	TOML_DISABLE_SWITCH_WARNINGS;                                                                                      \
-	TOML_DISABLE_SPAM_WARNINGS;                                                                                        \
-	TOML_DISABLE_ARITHMETIC_WARNINGS;                                                                                  \
-	static_assert(true)
-
-#define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS
-
-#elif TOML_ICC
-
-#define TOML_PUSH_WARNINGS                                                                                             \
-	__pragma(warning(push))                                                                                            \
-	static_assert(true)
-
-#define TOML_DISABLE_SPAM_WARNINGS                                                                                     \
-	__pragma(warning(disable : 82))	  /* storage class is not first */                                                 \
-	__pragma(warning(disable : 111))  /* statement unreachable (false-positive) */                                     \
-	__pragma(warning(disable : 869))  /* unreferenced parameter */                                                     \
-	__pragma(warning(disable : 1011)) /* missing return (false-positive) */                                            \
-	__pragma(warning(disable : 2261)) /* assume expr side-effects discarded */                                         \
-	static_assert(true)
-
-#define TOML_POP_WARNINGS                                                                                              \
-	__pragma(warning(pop))                                                                                             \
-	static_assert(true)
-
-#define TOML_DISABLE_WARNINGS                                                                                          \
-	__pragma(warning(push, 0))                                                                                         \
-	TOML_DISABLE_SPAM_WARNINGS
-
-#define TOML_ENABLE_WARNINGS                                                                                           \
-	__pragma(warning(pop))                                                                                             \
-	static_assert(true)
-
-#elif TOML_GCC
-
-#define TOML_PUSH_WARNINGS                                                                                             \
-	TOML_PRAGMA_GCC(diagnostic push)                                                                                   \
-	static_assert(true)
-
-#define TOML_DISABLE_SWITCH_WARNINGS                                                                                   \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch")                                                                     \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch-enum")                                                                \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch-default")                                                             \
-	static_assert(true)
-
-#define TOML_DISABLE_ARITHMETIC_WARNINGS                                                                               \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wfloat-equal")                                                                \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wsign-conversion")                                                            \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wchar-subscripts")                                                            \
-	static_assert(true)
-
-#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS                                                                             \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wsuggest-attribute=const")                                                    \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wsuggest-attribute=pure")                                                     \
-	static_assert(true)
-
-#define TOML_DISABLE_SPAM_WARNINGS                                                                                     \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wpadded")                                                                     \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wcast-align")                                                                 \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wcomment")                                                                    \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wtype-limits")                                                                \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wuseless-cast")                                                               \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wchar-subscripts")                                                            \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wsubobject-linkage")                                                          \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wmissing-field-initializers")                                                 \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wmaybe-uninitialized")                                                        \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wnoexcept")                                                                   \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wnull-dereference")                                                           \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wduplicated-branches")                                                        \
-	static_assert(true)
-
-#define TOML_POP_WARNINGS                                                                                              \
-	TOML_PRAGMA_GCC(diagnostic pop)                                                                                    \
-	static_assert(true)
-
-#define TOML_DISABLE_WARNINGS                                                                                          \
-	TOML_PRAGMA_GCC(diagnostic push)                                                                                   \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wall")                                                                        \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wextra")                                                                      \
-	TOML_PRAGMA_GCC(diagnostic ignored "-Wpedantic")                                                                   \
-	TOML_DISABLE_SWITCH_WARNINGS;                                                                                      \
-	TOML_DISABLE_ARITHMETIC_WARNINGS;                                                                                  \
-	TOML_DISABLE_SUGGEST_ATTR_WARNINGS;                                                                                \
-	TOML_DISABLE_SPAM_WARNINGS;                                                                                        \
-	static_assert(true)
-
-#define TOML_ENABLE_WARNINGS                                                                                           \
-	TOML_PRAGMA_GCC(diagnostic pop)                                                                                    \
-	static_assert(true)
-
-#endif
-
-#ifndef TOML_PUSH_WARNINGS
-#define TOML_PUSH_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_CODE_ANALYSIS_WARNINGS
-#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_SWITCH_WARNINGS
-#define TOML_DISABLE_SWITCH_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_SUGGEST_ATTR_WARNINGS
-#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_SPAM_WARNINGS
-#define TOML_DISABLE_SPAM_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_ARITHMETIC_WARNINGS
-#define TOML_DISABLE_ARITHMETIC_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_POP_WARNINGS
-#define TOML_POP_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_DISABLE_WARNINGS
-#define TOML_DISABLE_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_ENABLE_WARNINGS
-#define TOML_ENABLE_WARNINGS static_assert(true)
-#endif
-#ifndef TOML_SIMPLE_STATIC_ASSERT_MESSAGES
-#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 0
-#endif
-
-#ifdef TOML_CONFIG_HEADER
-#include TOML_CONFIG_HEADER
-#endif
-
-// is the library being built as a shared lib/dll using meson and friends?
-#ifndef TOML_SHARED_LIB
-#define TOML_SHARED_LIB 0
-#endif
-
-// header-only mode
-#if !defined(TOML_HEADER_ONLY) && defined(TOML_ALL_INLINE) // was TOML_ALL_INLINE pre-2.0
-#define TOML_HEADER_ONLY TOML_ALL_INLINE
-#endif
-#if !defined(TOML_HEADER_ONLY) || (defined(TOML_HEADER_ONLY) && TOML_HEADER_ONLY) || TOML_INTELLISENSE
-#undef TOML_HEADER_ONLY
-#define TOML_HEADER_ONLY 1
-#endif
-#if TOML_DOXYGEN || TOML_SHARED_LIB
-#undef TOML_HEADER_ONLY
-#define TOML_HEADER_ONLY 0
-#endif
-
-// internal implementation switch
-#if defined(TOML_IMPLEMENTATION) || TOML_HEADER_ONLY
-#undef TOML_IMPLEMENTATION
-#define TOML_IMPLEMENTATION 1
-#else
-#define TOML_IMPLEMENTATION 0
-#endif
-
-// dll/shared lib function exports (legacy - TOML_API was the old name for this setting)
-#if !defined(TOML_EXPORTED_MEMBER_FUNCTION) && !defined(TOML_EXPORTED_STATIC_FUNCTION)                                 \
-	&& !defined(TOML_EXPORTED_FREE_FUNCTION) && !defined(TOML_EXPORTED_CLASS) && defined(TOML_API)
-#define TOML_EXPORTED_MEMBER_FUNCTION TOML_API
-#define TOML_EXPORTED_STATIC_FUNCTION TOML_API
-#define TOML_EXPORTED_FREE_FUNCTION	  TOML_API
-#endif
-
-// dll/shared lib exports
-#if TOML_SHARED_LIB
-#undef TOML_API
-#undef TOML_EXPORTED_CLASS
-#undef TOML_EXPORTED_MEMBER_FUNCTION
-#undef TOML_EXPORTED_STATIC_FUNCTION
-#undef TOML_EXPORTED_FREE_FUNCTION
-#if TOML_WINDOWS
-#if TOML_IMPLEMENTATION
-#define TOML_EXPORTED_CLASS			__declspec(dllexport)
-#define TOML_EXPORTED_FREE_FUNCTION __declspec(dllexport)
-#else
-#define TOML_EXPORTED_CLASS			__declspec(dllimport)
-#define TOML_EXPORTED_FREE_FUNCTION __declspec(dllimport)
-#endif
-#ifndef TOML_CALLCONV
-#define TOML_CALLCONV __cdecl
-#endif
-#elif defined(__GNUC__) && __GNUC__ >= 4
-#define TOML_EXPORTED_CLASS			  __attribute__((visibility("default")))
-#define TOML_EXPORTED_MEMBER_FUNCTION __attribute__((visibility("default")))
-#define TOML_EXPORTED_STATIC_FUNCTION __attribute__((visibility("default")))
-#define TOML_EXPORTED_FREE_FUNCTION	  __attribute__((visibility("default")))
-#endif
-#endif
-#ifndef TOML_EXPORTED_CLASS
-#define TOML_EXPORTED_CLASS
-#endif
-#ifndef TOML_EXPORTED_MEMBER_FUNCTION
-#define TOML_EXPORTED_MEMBER_FUNCTION
-#endif
-#ifndef TOML_EXPORTED_STATIC_FUNCTION
-#define TOML_EXPORTED_STATIC_FUNCTION
-#endif
-#ifndef TOML_EXPORTED_FREE_FUNCTION
-#define TOML_EXPORTED_FREE_FUNCTION
-#endif
-
-// experimental language features
-#if !defined(TOML_ENABLE_UNRELEASED_FEATURES) && defined(TOML_UNRELEASED_FEATURES) // was TOML_UNRELEASED_FEATURES
-																				   // pre-3.0
-#define TOML_ENABLE_UNRELEASED_FEATURES TOML_UNRELEASED_FEATURES
-#endif
-#if (defined(TOML_ENABLE_UNRELEASED_FEATURES) && TOML_ENABLE_UNRELEASED_FEATURES) || TOML_INTELLISENSE
-#undef TOML_ENABLE_UNRELEASED_FEATURES
-#define TOML_ENABLE_UNRELEASED_FEATURES 1
-#endif
-#ifndef TOML_ENABLE_UNRELEASED_FEATURES
-#define TOML_ENABLE_UNRELEASED_FEATURES 0
-#endif
-
-// parser
-#if !defined(TOML_ENABLE_PARSER) && defined(TOML_PARSER) // was TOML_PARSER pre-3.0
-#define TOML_ENABLE_PARSER TOML_PARSER
-#endif
-#if !defined(TOML_ENABLE_PARSER) || (defined(TOML_ENABLE_PARSER) && TOML_ENABLE_PARSER) || TOML_INTELLISENSE
-#undef TOML_ENABLE_PARSER
-#define TOML_ENABLE_PARSER 1
-#endif
-
-// formatters
-#if !defined(TOML_ENABLE_FORMATTERS) || (defined(TOML_ENABLE_FORMATTERS) && TOML_ENABLE_FORMATTERS) || TOML_INTELLISENSE
-#undef TOML_ENABLE_FORMATTERS
-#define TOML_ENABLE_FORMATTERS 1
-#endif
-
-// SIMD
-#if !defined(TOML_ENABLE_SIMD) || (defined(TOML_ENABLE_SIMD) && TOML_ENABLE_SIMD) || TOML_INTELLISENSE
-#undef TOML_ENABLE_SIMD
-#define TOML_ENABLE_SIMD 1
-#endif
-
-// windows compat
-#if !defined(TOML_ENABLE_WINDOWS_COMPAT) && defined(TOML_WINDOWS_COMPAT) // was TOML_WINDOWS_COMPAT pre-3.0
-#define TOML_ENABLE_WINDOWS_COMPAT TOML_WINDOWS_COMPAT
-#endif
-#if !defined(TOML_ENABLE_WINDOWS_COMPAT) || (defined(TOML_ENABLE_WINDOWS_COMPAT) && TOML_ENABLE_WINDOWS_COMPAT)        \
-	|| TOML_INTELLISENSE
-#undef TOML_ENABLE_WINDOWS_COMPAT
-#define TOML_ENABLE_WINDOWS_COMPAT 1
-#endif
-
-#if !TOML_WINDOWS
-#undef TOML_ENABLE_WINDOWS_COMPAT
-#define TOML_ENABLE_WINDOWS_COMPAT 0
-#endif
-
-#ifndef TOML_INCLUDE_WINDOWS_H
-#define TOML_INCLUDE_WINDOWS_H 0
-#endif
-
-// custom optional
-#ifdef TOML_OPTIONAL_TYPE
-#define TOML_HAS_CUSTOM_OPTIONAL_TYPE 1
-#else
-#define TOML_HAS_CUSTOM_OPTIONAL_TYPE 0
-#endif
-
-// exceptions (library use)
-#if TOML_COMPILER_HAS_EXCEPTIONS
-#if !defined(TOML_EXCEPTIONS) || (defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS)
-#undef TOML_EXCEPTIONS
-#define TOML_EXCEPTIONS 1
-#endif
-#else
-#if defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS
-#error TOML_EXCEPTIONS was explicitly enabled but exceptions are disabled/unsupported by the compiler.
-#endif
-#undef TOML_EXCEPTIONS
-#define TOML_EXCEPTIONS 0
-#endif
-
-// calling convention for static/free/friend functions
-#ifndef TOML_CALLCONV
-#define TOML_CALLCONV
-#endif
-
-#ifndef TOML_UNDEF_MACROS
-#define TOML_UNDEF_MACROS 1
-#endif
-
-#ifndef TOML_MAX_NESTED_VALUES
-#define TOML_MAX_NESTED_VALUES 256
-// this refers to the depth of nested values, e.g. inline tables and arrays.
-// 256 is crazy high! if you're hitting this limit with real input, TOML is probably the wrong tool for the job...
-#endif
-
-#ifdef TOML_CHAR_8_STRINGS
-#if TOML_CHAR_8_STRINGS
-#error TOML_CHAR_8_STRINGS was removed in toml++ 2.0.0; all value setters and getters now work with char8_t strings implicitly.
-#endif
-#endif
-
-#ifdef TOML_LARGE_FILES
-#if !TOML_LARGE_FILES
-#error Support for !TOML_LARGE_FILES (i.e. 'small files') was removed in toml++ 3.0.0.
-#endif
-#endif
-
-#ifndef TOML_LIFETIME_HOOKS
-#define TOML_LIFETIME_HOOKS 0
-#endif
-
-#ifdef NDEBUG
-#undef TOML_ASSERT
-#define TOML_ASSERT(expr) static_assert(true)
-#endif
-#ifndef TOML_ASSERT
-#ifndef assert
-TOML_DISABLE_WARNINGS;
-#include <cassert>
-TOML_ENABLE_WARNINGS;
-#endif
-#define TOML_ASSERT(expr) assert(expr)
-#endif
-#ifdef NDEBUG
-#define TOML_ASSERT_ASSUME(expr) TOML_ASSUME(expr)
-#else
-#define TOML_ASSERT_ASSUME(expr) TOML_ASSERT(expr)
-#endif
-
-#if !defined(TOML_FLOAT_CHARCONV) && (TOML_GCC || TOML_CLANG || (TOML_ICC && !TOML_ICC_CL))
-// not supported by any version of GCC or Clang as of 26/11/2020
-// not supported by any version of ICC on Linux as of 11/01/2021
-#define TOML_FLOAT_CHARCONV 0
-#endif
-#if !defined(TOML_INT_CHARCONV) && (defined(__EMSCRIPTEN__) || defined(__APPLE__))
-// causes link errors on emscripten
-// causes Mac OS SDK version errors on some versions of Apple Clang
-#define TOML_INT_CHARCONV 0
-#endif
-#ifndef TOML_INT_CHARCONV
-#define TOML_INT_CHARCONV 1
-#endif
-#ifndef TOML_FLOAT_CHARCONV
-#define TOML_FLOAT_CHARCONV 1
-#endif
-#if (TOML_INT_CHARCONV || TOML_FLOAT_CHARCONV) && !TOML_HAS_INCLUDE(<charconv>)
-#undef TOML_INT_CHARCONV
-#undef TOML_FLOAT_CHARCONV
-#define TOML_INT_CHARCONV	0
-#define TOML_FLOAT_CHARCONV 0
-#endif
-
-#if defined(__cpp_concepts) && __cpp_concepts >= 201907
-#define TOML_REQUIRES(...) requires(__VA_ARGS__)
-#else
-#define TOML_REQUIRES(...)
-#endif
-#define TOML_ENABLE_IF(...) , typename std::enable_if<(__VA_ARGS__), int>::type = 0
-#define TOML_CONSTRAINED_TEMPLATE(condition, ...)                                                                      \
-	template <__VA_ARGS__ TOML_ENABLE_IF(condition)>                                                                   \
-	TOML_REQUIRES(condition)
-#define TOML_HIDDEN_CONSTRAINT(condition, ...) TOML_CONSTRAINED_TEMPLATE(condition, __VA_ARGS__)
-
-#ifndef TOML_ENABLE_FLOAT16
-
-#ifdef __FLT16_MANT_DIG__
-#define TOML_FLOAT16_MANT_DIG	__FLT16_MANT_DIG__
-#define TOML_FLOAT16_DIG		__FLT16_DIG__
-#define TOML_FLOAT16_MIN_EXP	__FLT16_MIN_EXP__
-#define TOML_FLOAT16_MIN_10_EXP __FLT16_MIN_10_EXP__
-#define TOML_FLOAT16_MAX_EXP	__FLT16_MAX_EXP__
-#define TOML_FLOAT16_MAX_10_EXP __FLT16_MAX_10_EXP__
-#else
-#define TOML_FLOAT16_MANT_DIG	0
-#define TOML_FLOAT16_DIG		0
-#define TOML_FLOAT16_MIN_EXP	0
-#define TOML_FLOAT16_MIN_10_EXP 0
-#define TOML_FLOAT16_MAX_EXP	0
-#define TOML_FLOAT16_MAX_10_EXP 0
-#endif
-
-#if (TOML_FLOAT16_MANT_DIG && TOML_FLOAT16_DIG && TOML_FLOAT16_MIN_EXP && TOML_FLOAT16_MIN_10_EXP                      \
-	 && TOML_FLOAT16_MAX_EXP && TOML_FLOAT16_MAX_10_EXP)
-#define TOML_FLOAT16_LIMITS_SET 1
-#else
-#define TOML_FLOAT16_LIMITS_SET 0
-#endif
-
-#if TOML_FLOAT16_LIMITS_SET
-
-#if TOML_CLANG // >= 15
-#if (TOML_ARCH_ARM || TOML_ARCH_AMD64 || TOML_ARCH_X86)
-#define TOML_ENABLE_FLOAT16 1
-#endif
-
-#elif TOML_GCC
-#if (TOML_ARCH_ARM || TOML_ARCH_AMD64 /* || TOML_ARCH_X86*/)
-#define TOML_ENABLE_FLOAT16 1
-#endif
-
-#endif // clang/gcc
-
-#endif // TOML_FLOAT16_LIMITS_SET
-
-#endif // !defined(TOML_ENABLE_FLOAT16)
-
-#ifndef TOML_ENABLE_FLOAT16
-#define TOML_ENABLE_FLOAT16 0
-#endif
-
-#if defined(__SIZEOF_FLOAT128__) && defined(__FLT128_MANT_DIG__) && defined(__LDBL_MANT_DIG__)                         \
-	&& __FLT128_MANT_DIG__ > __LDBL_MANT_DIG__
-#define TOML_FLOAT128 __float128
-#endif
-
-#ifdef __SIZEOF_INT128__
-#define TOML_INT128	 __int128_t
-#define TOML_UINT128 __uint128_t
-#endif
-
-// clang-format off
-
-//********  impl/version.h  ********************************************************************************************
-
-#define TOML_LIB_MAJOR 3
-#define TOML_LIB_MINOR 2
-#define TOML_LIB_PATCH 0
-
-#define TOML_LANG_MAJOR 1
-#define TOML_LANG_MINOR 0
-#define TOML_LANG_PATCH 0
-
-//********  impl/preprocessor.h  ***************************************************************************************
-
-#define	TOML_LIB_SINGLE_HEADER 1
-
-#define TOML_MAKE_VERSION(major, minor, patch)											\
-		((major) * 10000 + (minor) * 100 + (patch))
-
-#if TOML_ENABLE_UNRELEASED_FEATURES
-	#define TOML_LANG_EFFECTIVE_VERSION													\
-		TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH+1)
-#else
-	#define TOML_LANG_EFFECTIVE_VERSION													\
-		TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
-#endif
-
-#define TOML_LANG_HIGHER_THAN(major, minor, patch)										\
-		(TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(major, minor, patch))
-
-#define TOML_LANG_AT_LEAST(major, minor, patch)											\
-		(TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(major, minor, patch))
-
-#define TOML_LANG_UNRELEASED															\
-		TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
-
-#ifndef TOML_ABI_NAMESPACES
-	#if TOML_DOXYGEN
-		#define TOML_ABI_NAMESPACES 0
-	#else
-		#define TOML_ABI_NAMESPACES 1
-	#endif
-#endif
-#if TOML_ABI_NAMESPACES
-	#define TOML_NAMESPACE_START				namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR)
-	#define TOML_NAMESPACE_END					} static_assert(true)
-	#define TOML_NAMESPACE						::toml::TOML_CONCAT(v, TOML_LIB_MAJOR)
-	#define TOML_ABI_NAMESPACE_START(name)		inline namespace name { static_assert(true)
-	#define TOML_ABI_NAMESPACE_BOOL(cond, T, F)	TOML_ABI_NAMESPACE_START(TOML_CONCAT(TOML_EVAL_BOOL_, cond)(T, F))
-	#define TOML_ABI_NAMESPACE_END				} static_assert(true)
-#else
-	#define TOML_NAMESPACE_START				namespace toml
-	#define TOML_NAMESPACE_END					static_assert(true)
-	#define TOML_NAMESPACE						toml
-	#define TOML_ABI_NAMESPACE_START(...)		static_assert(true)
-	#define TOML_ABI_NAMESPACE_BOOL(...)		static_assert(true)
-	#define TOML_ABI_NAMESPACE_END				static_assert(true)
-#endif
-#define TOML_IMPL_NAMESPACE_START				TOML_NAMESPACE_START { namespace impl
-#define TOML_IMPL_NAMESPACE_END					} TOML_NAMESPACE_END
-#if TOML_HEADER_ONLY
-	#define TOML_ANON_NAMESPACE_START			static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START
-	#define TOML_ANON_NAMESPACE_END				TOML_IMPL_NAMESPACE_END
-	#define TOML_ANON_NAMESPACE					TOML_NAMESPACE::impl
-	#define TOML_EXTERNAL_LINKAGE				inline
-	#define TOML_INTERNAL_LINKAGE				inline
-#else
-	#define TOML_ANON_NAMESPACE_START			static_assert(TOML_IMPLEMENTATION);	\
-												using namespace toml;				\
-												namespace
-	#define TOML_ANON_NAMESPACE_END				static_assert(true)
-	#define TOML_ANON_NAMESPACE
-	#define TOML_EXTERNAL_LINKAGE
-	#define TOML_INTERNAL_LINKAGE				static
-#endif
-
-// clang-format on
-
-// clang-format off
-
-#if TOML_SIMPLE_STATIC_ASSERT_MESSAGES
-
-	#define TOML_SA_NEWLINE		" "
-	#define TOML_SA_LIST_SEP	", "
-	#define TOML_SA_LIST_BEG	" ("
-	#define TOML_SA_LIST_END	")"
-	#define TOML_SA_LIST_NEW	" "
-	#define TOML_SA_LIST_NXT	", "
-
-#else
-
-	#define TOML_SA_NEWLINE			"\n| "
-	#define TOML_SA_LIST_SEP		TOML_SA_NEWLINE "  - "
-	#define TOML_SA_LIST_BEG		TOML_SA_LIST_SEP
-	#define TOML_SA_LIST_END
-	#define TOML_SA_LIST_NEW		TOML_SA_NEWLINE TOML_SA_NEWLINE
-	#define TOML_SA_LIST_NXT		TOML_SA_LIST_NEW
-
-#endif
-
-#define TOML_SA_NATIVE_VALUE_TYPE_LIST							\
-	TOML_SA_LIST_BEG	"std::string"							\
-	TOML_SA_LIST_SEP	"int64_t"								\
-	TOML_SA_LIST_SEP	"double"								\
-	TOML_SA_LIST_SEP	"bool"									\
-	TOML_SA_LIST_SEP	"toml::date"							\
-	TOML_SA_LIST_SEP	"toml::time"							\
-	TOML_SA_LIST_SEP	"toml::date_time"						\
-	TOML_SA_LIST_END
-
-#define TOML_SA_NODE_TYPE_LIST									\
-	TOML_SA_LIST_BEG	"toml::table"							\
-	TOML_SA_LIST_SEP	"toml::array"							\
-	TOML_SA_LIST_SEP	"toml::value<std::string>"				\
-	TOML_SA_LIST_SEP	"toml::value<int64_t>"					\
-	TOML_SA_LIST_SEP	"toml::value<double>"					\
-	TOML_SA_LIST_SEP	"toml::value<bool>"						\
-	TOML_SA_LIST_SEP	"toml::value<toml::date>"				\
-	TOML_SA_LIST_SEP	"toml::value<toml::time>"				\
-	TOML_SA_LIST_SEP	"toml::value<toml::date_time>"			\
-	TOML_SA_LIST_END
-
-#define TOML_SA_UNWRAPPED_NODE_TYPE_LIST						\
-	TOML_SA_LIST_NEW	"A native TOML value type"				\
-	TOML_SA_NATIVE_VALUE_TYPE_LIST								\
-																\
-	TOML_SA_LIST_NXT	"A TOML node type"						\
-	TOML_SA_NODE_TYPE_LIST
-
-// clang-format on
-
-TOML_PUSH_WARNINGS;
-TOML_DISABLE_SPAM_WARNINGS;
-TOML_DISABLE_SWITCH_WARNINGS;
-TOML_DISABLE_SUGGEST_ATTR_WARNINGS;
-
-// misc warning false-positives
-#if TOML_MSVC
-#pragma warning(disable : 5031) // #pragma warning(pop): likely mismatch
-#if TOML_SHARED_LIB
-#pragma warning(disable : 4251) // dll exports for std lib types
-#endif
-#elif TOML_CLANG
-#pragma clang diagnostic ignored "-Wheader-hygiene"
-#if TOML_CLANG >= 12
-#pragma clang diagnostic ignored "-Wc++20-extensions"
-#endif
-#if (TOML_CLANG == 13) && !defined(__APPLE__)
-#pragma clang diagnostic ignored "-Wreserved-identifier"
-#endif
-#endif
-
-//********  impl/std_new.h  ********************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <new>
-TOML_ENABLE_WARNINGS;
-
-#if TOML_CLANG >= 8 || TOML_GCC >= 7 || TOML_ICC >= 1910 || TOML_MSVC >= 1914
-#define TOML_LAUNDER(x) __builtin_launder(x)
-#elif defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
-#define TOML_LAUNDER(x) std::launder(x)
-#else
-#define TOML_LAUNDER(x) x
-#endif
-
-//********  impl/std_string.h  *****************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <string_view>
-#include <string>
-TOML_ENABLE_WARNINGS;
-
-#if TOML_DOXYGEN                                                                                                       \
-	|| (defined(__cpp_char8_t) && __cpp_char8_t >= 201811 && defined(__cpp_lib_char8_t)                                \
-		&& __cpp_lib_char8_t >= 201907)
-#define TOML_HAS_CHAR8 1
-#else
-#define TOML_HAS_CHAR8 0
-#endif
-
-namespace toml // non-abi namespace; this is not an error
-{
-	using namespace std::string_literals;
-	using namespace std::string_view_literals;
-}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	std::string narrow(std::wstring_view);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	std::wstring widen(std::string_view);
-
-#if TOML_HAS_CHAR8
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	std::wstring widen(std::u8string_view);
-
-#endif
-}
-TOML_IMPL_NAMESPACE_END;
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-//********  impl/std_optional.h  ***************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#if !TOML_HAS_CUSTOM_OPTIONAL_TYPE
-#include <optional>
-#endif
-TOML_ENABLE_WARNINGS;
-
-TOML_NAMESPACE_START
-{
-#if TOML_HAS_CUSTOM_OPTIONAL_TYPE
-
-	template <typename T>
-	using optional = TOML_OPTIONAL_TYPE<T>;
-
-#else
-
-	template <typename T>
-	using optional = std::optional<T>;
-
-#endif
-}
-TOML_NAMESPACE_END;
-
-//********  impl/forward_declarations.h  *******************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <cstdint>
-#include <cstddef>
-#include <cstring>
-#include <cfloat>
-#include <climits>
-#include <cmath>
-#include <limits>
-#include <memory>
-#include <iosfwd>
-#include <type_traits>
-TOML_ENABLE_WARNINGS;
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-#ifndef TOML_DISABLE_ENVIRONMENT_CHECKS
-#define TOML_ENV_MESSAGE                                                                                               \
-	"If you're seeing this error it's because you're building toml++ for an environment that doesn't conform to "      \
-	"one of the 'ground truths' assumed by the library. Essentially this just means that I don't have the "            \
-	"resources to test on more platforms, but I wish I did! You can try disabling the checks by defining "             \
-	"TOML_DISABLE_ENVIRONMENT_CHECKS, but your mileage may vary. Please consider filing an issue at "                  \
-	"https://github.com/marzer/tomlplusplus/issues to help me improve support for your target environment. "           \
-	"Thanks!"
-
-static_assert(CHAR_BIT == 8, TOML_ENV_MESSAGE);
-static_assert(FLT_RADIX == 2, TOML_ENV_MESSAGE);
-static_assert('A' == 65, TOML_ENV_MESSAGE);
-static_assert(sizeof(double) == 8, TOML_ENV_MESSAGE);
-static_assert(std::numeric_limits<double>::is_iec559, TOML_ENV_MESSAGE);
-static_assert(std::numeric_limits<double>::digits == 53, TOML_ENV_MESSAGE);
-static_assert(std::numeric_limits<double>::digits10 == 15, TOML_ENV_MESSAGE);
-
-#undef TOML_ENV_MESSAGE
-#endif // !TOML_DISABLE_ENVIRONMENT_CHECKS
-
-// undocumented forward declarations are hidden from doxygen because they fuck it up =/
-
-namespace toml // non-abi namespace; this is not an error
-{
-	using ::std::size_t;
-	using ::std::intptr_t;
-	using ::std::uintptr_t;
-	using ::std::ptrdiff_t;
-	using ::std::nullptr_t;
-	using ::std::int8_t;
-	using ::std::int16_t;
-	using ::std::int32_t;
-	using ::std::int64_t;
-	using ::std::uint8_t;
-	using ::std::uint16_t;
-	using ::std::uint32_t;
-	using ::std::uint64_t;
-	using ::std::uint_least32_t;
-	using ::std::uint_least64_t;
-}
-
-TOML_NAMESPACE_START
-{
-	struct date;
-	struct time;
-	struct time_offset;
-
-	TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt);
-	struct date_time;
-	TOML_ABI_NAMESPACE_END;
-
-	struct source_position;
-	struct source_region;
-
-	class node;
-	template <typename>
-	class node_view;
-
-	class key;
-	class array;
-	class table;
-	template <typename>
-	class value;
-
-	class path;
-
-	class toml_formatter;
-	class json_formatter;
-	class yaml_formatter;
-
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
-#if TOML_EXCEPTIONS
-	using parse_result = table;
-#else
-	class parse_result;
-#endif
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-}
-TOML_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	using node_ptr = std::unique_ptr<node>;
-
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, impl_ex, impl_noex);
-	class parser;
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-
-	// clang-format off
-
-	inline constexpr std::string_view control_char_escapes[] =
-	{
-		"\\u0000"sv,
-		"\\u0001"sv,
-		"\\u0002"sv,
-		"\\u0003"sv,
-		"\\u0004"sv,
-		"\\u0005"sv,
-		"\\u0006"sv,
-		"\\u0007"sv,
-		"\\b"sv,
-		"\\t"sv,
-		"\\n"sv,
-		"\\u000B"sv,
-		"\\f"sv,
-		"\\r"sv,
-		"\\u000E"sv,
-		"\\u000F"sv,
-		"\\u0010"sv,
-		"\\u0011"sv,
-		"\\u0012"sv,
-		"\\u0013"sv,
-		"\\u0014"sv,
-		"\\u0015"sv,
-		"\\u0016"sv,
-		"\\u0017"sv,
-		"\\u0018"sv,
-		"\\u0019"sv,
-		"\\u001A"sv,
-		"\\u001B"sv,
-		"\\u001C"sv,
-		"\\u001D"sv,
-		"\\u001E"sv,
-		"\\u001F"sv,
-	};
-
-	inline constexpr std::string_view node_type_friendly_names[] =
-	{
-		"none"sv,
-		"table"sv,
-		"array"sv,
-		"string"sv,
-		"integer"sv,
-		"floating-point"sv,
-		"boolean"sv,
-		"date"sv,
-		"time"sv,
-		"date-time"sv
-	};
-
-	// clang-format on
-}
-TOML_IMPL_NAMESPACE_END;
-
-#if TOML_ABI_NAMESPACES
-#if TOML_EXCEPTIONS
-#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_ex::parser
-#else
-#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_noex::parser
-#endif
-#else
-#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::parser
-#endif
-
-namespace toml
-{
-}
-
-TOML_NAMESPACE_START // abi namespace
-{
-	inline namespace literals
-	{
-	}
-
-	enum class TOML_CLOSED_ENUM node_type : uint8_t
-	{
-		none,
-		table,
-		array,
-		string,
-		integer,
-		floating_point,
-		boolean,
-		date,
-		time,
-		date_time
-	};
-
-	template <typename Char>
-	inline std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& lhs, node_type rhs)
-	{
-		const auto str	 = impl::node_type_friendly_names[static_cast<std::underlying_type_t<node_type>>(rhs)];
-		using str_char_t = decltype(str)::value_type;
-		if constexpr (std::is_same_v<Char, str_char_t>)
-			return lhs << str;
-		else
-		{
-			if constexpr (sizeof(Char) == sizeof(str_char_t))
-				return lhs << std::basic_string_view<Char>{ reinterpret_cast<const Char*>(str.data()), str.length() };
-			else
-				return lhs << str.data();
-		}
-	}
-
-	enum class TOML_OPEN_FLAGS_ENUM value_flags : uint16_t // being an "OPEN" flags enum is not an error
-	{
-		none,
-		format_as_binary = 1,
-		format_as_octal = 2,
-		format_as_hexadecimal = 3,
-	};
-	TOML_MAKE_FLAGS(value_flags);
-
-	inline constexpr value_flags preserve_source_value_flags =
-		POXY_IMPLEMENTATION_DETAIL(value_flags{ static_cast<std::underlying_type_t<value_flags>>(-1) });
-
-	enum class TOML_CLOSED_FLAGS_ENUM format_flags : uint64_t
-	{
-		none,
-		quote_dates_and_times = (1ull << 0),
-		quote_infinities_and_nans = (1ull << 1),
-		allow_literal_strings = (1ull << 2),
-		allow_multi_line_strings = (1ull << 3),
-		allow_real_tabs_in_strings = (1ull << 4),
-		allow_unicode_strings = (1ull << 5),
-		allow_binary_integers = (1ull << 6),
-		allow_octal_integers = (1ull << 7),
-		allow_hexadecimal_integers = (1ull << 8),
-		indent_sub_tables = (1ull << 9),
-		indent_array_elements = (1ull << 10),
-		indentation = indent_sub_tables | indent_array_elements,
-		relaxed_float_precision = (1ull << 11),
-		terse_key_value_pairs = (1ull << 12),
-	};
-	TOML_MAKE_FLAGS(format_flags);
-
-	template <typename T>
-	struct TOML_TRIVIAL_ABI inserter
-	{
-		static_assert(std::is_reference_v<T>);
-
-		T value;
-	};
-	template <typename T>
-	inserter(T &&) -> inserter<T&&>;
-	template <typename T>
-	inserter(T&) -> inserter<T&>;
-
-	using default_formatter = toml_formatter;
-}
-TOML_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <typename T>
-	using remove_cvref = std::remove_cv_t<std::remove_reference_t<T>>;
-
-	template <typename... T>
-	using common_signed_type = std::common_type_t<std::make_signed_t<T>...>;
-
-	template <typename T, typename... U>
-	inline constexpr bool is_one_of = (false || ... || std::is_same_v<T, U>);
-
-	template <typename... T>
-	inline constexpr bool all_integral = (std::is_integral_v<T> && ...);
-
-	template <typename T>
-	inline constexpr bool is_cvref = std::is_reference_v<T> || std::is_const_v<T> || std::is_volatile_v<T>;
-
-	template <typename T>
-	inline constexpr bool is_wide_string =
-		is_one_of<std::decay_t<T>, const wchar_t*, wchar_t*, std::wstring_view, std::wstring>;
-
-	template <typename T>
-	inline constexpr bool value_retrieval_is_nothrow = !std::is_same_v<remove_cvref<T>, std::string>
-#if TOML_HAS_CHAR8
-													&& !std::is_same_v<remove_cvref<T>, std::u8string>
-#endif
-
-													&& !is_wide_string<T>;
-
-	template <typename, typename>
-	struct copy_ref_;
-	template <typename Dest, typename Src>
-	using copy_ref = typename copy_ref_<Dest, Src>::type;
-
-	template <typename Dest, typename Src>
-	struct copy_ref_
-	{
-		using type = Dest;
-	};
-
-	template <typename Dest, typename Src>
-	struct copy_ref_<Dest, Src&>
-	{
-		using type = std::add_lvalue_reference_t<Dest>;
-	};
-
-	template <typename Dest, typename Src>
-	struct copy_ref_<Dest, Src&&>
-	{
-		using type = std::add_rvalue_reference_t<Dest>;
-	};
-
-	template <typename, typename>
-	struct copy_cv_;
-	template <typename Dest, typename Src>
-	using copy_cv = typename copy_cv_<Dest, Src>::type;
-
-	template <typename Dest, typename Src>
-	struct copy_cv_
-	{
-		using type = Dest;
-	};
-
-	template <typename Dest, typename Src>
-	struct copy_cv_<Dest, const Src>
-	{
-		using type = std::add_const_t<Dest>;
-	};
-
-	template <typename Dest, typename Src>
-	struct copy_cv_<Dest, volatile Src>
-	{
-		using type = std::add_volatile_t<Dest>;
-	};
-
-	template <typename Dest, typename Src>
-	struct copy_cv_<Dest, const volatile Src>
-	{
-		using type = std::add_cv_t<Dest>;
-	};
-
-	template <typename Dest, typename Src>
-	using copy_cvref =
-		copy_ref<copy_ref<copy_cv<std::remove_reference_t<Dest>, std::remove_reference_t<Src>>, Dest>, Src>;
-
-	template <typename T>
-	inline constexpr bool dependent_false = false;
-
-	template <typename T, typename... U>
-	inline constexpr bool first_is_same = false;
-	template <typename T, typename... U>
-	inline constexpr bool first_is_same<T, T, U...> = true;
-
-	// general value traits
-	// (as they relate to their equivalent native TOML type)
-	template <typename T>
-	struct value_traits
-	{
-		using native_type										  = void;
-		static constexpr bool is_native							  = false;
-		static constexpr bool is_losslessly_convertible_to_native = false;
-		static constexpr bool can_represent_native				  = false;
-		static constexpr bool can_partially_represent_native	  = false;
-		static constexpr auto type								  = node_type::none;
-	};
-
-	template <typename T>
-	struct value_traits<const T> : value_traits<T>
-	{};
-	template <typename T>
-	struct value_traits<volatile T> : value_traits<T>
-	{};
-	template <typename T>
-	struct value_traits<const volatile T> : value_traits<T>
-	{};
-	template <typename T>
-	struct value_traits<T&> : value_traits<T>
-	{};
-	template <typename T>
-	struct value_traits<T&&> : value_traits<T>
-	{};
-
-	// integer value_traits specializations - standard types
-	template <typename T>
-	struct integer_limits
-	{
-		static constexpr auto min = (std::numeric_limits<T>::min)();
-		static constexpr auto max = (std::numeric_limits<T>::max)();
-	};
-	template <typename T>
-	struct integer_traits_base : integer_limits<T>
-	{
-		using native_type				= int64_t;
-		static constexpr bool is_native = std::is_same_v<T, native_type>;
-		static constexpr bool is_signed = static_cast<T>(-1) < T{}; // for impls not specializing std::is_signed<T>
-		static constexpr auto type		= node_type::integer;
-		static constexpr bool can_partially_represent_native = true;
-	};
-	template <typename T>
-	struct unsigned_integer_traits : integer_traits_base<T>
-	{
-		static constexpr bool is_losslessly_convertible_to_native = integer_limits<T>::max <= 9223372036854775807ULL;
-		static constexpr bool can_represent_native				  = false;
-	};
-	template <typename T>
-	struct signed_integer_traits : integer_traits_base<T>
-	{
-		using native_type = int64_t;
-		static constexpr bool is_losslessly_convertible_to_native =
-			integer_limits<T>::min >= (-9223372036854775807LL - 1LL) && integer_limits<T>::max <= 9223372036854775807LL;
-		static constexpr bool can_represent_native =
-			integer_limits<T>::min <= (-9223372036854775807LL - 1LL) && integer_limits<T>::max >= 9223372036854775807LL;
-	};
-	template <typename T, bool S = integer_traits_base<T>::is_signed>
-	struct integer_traits : signed_integer_traits<T>
-	{};
-	template <typename T>
-	struct integer_traits<T, false> : unsigned_integer_traits<T>
-	{};
-	template <>
-	struct value_traits<signed char> : integer_traits<signed char>
-	{};
-	template <>
-	struct value_traits<unsigned char> : integer_traits<unsigned char>
-	{};
-	template <>
-	struct value_traits<signed short> : integer_traits<signed short>
-	{};
-	template <>
-	struct value_traits<unsigned short> : integer_traits<unsigned short>
-	{};
-	template <>
-	struct value_traits<signed int> : integer_traits<signed int>
-	{};
-	template <>
-	struct value_traits<unsigned int> : integer_traits<unsigned int>
-	{};
-	template <>
-	struct value_traits<signed long> : integer_traits<signed long>
-	{};
-	template <>
-	struct value_traits<unsigned long> : integer_traits<unsigned long>
-	{};
-	template <>
-	struct value_traits<signed long long> : integer_traits<signed long long>
-	{};
-	template <>
-	struct value_traits<unsigned long long> : integer_traits<unsigned long long>
-	{};
-	static_assert(value_traits<int64_t>::is_native);
-	static_assert(value_traits<int64_t>::is_signed);
-	static_assert(value_traits<int64_t>::is_losslessly_convertible_to_native);
-	static_assert(value_traits<int64_t>::can_represent_native);
-	static_assert(value_traits<int64_t>::can_partially_represent_native);
-
-	// integer value_traits specializations - non-standard types
-#ifdef TOML_INT128
-	template <>
-	struct integer_limits<TOML_INT128>
-	{
-		static constexpr TOML_INT128 max =
-			static_cast<TOML_INT128>((TOML_UINT128{ 1u } << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1);
-		static constexpr TOML_INT128 min = -max - TOML_INT128{ 1 };
-	};
-	template <>
-	struct integer_limits<TOML_UINT128>
-	{
-		static constexpr TOML_UINT128 min = TOML_UINT128{};
-		static constexpr TOML_UINT128 max = (2u * static_cast<TOML_UINT128>(integer_limits<TOML_INT128>::max)) + 1u;
-	};
-	template <>
-	struct value_traits<TOML_INT128> : integer_traits<TOML_INT128>
-	{};
-	template <>
-	struct value_traits<TOML_UINT128> : integer_traits<TOML_UINT128>
-	{};
-#endif
-#ifdef TOML_SMALL_INT_TYPE
-	template <>
-	struct value_traits<TOML_SMALL_INT_TYPE> : signed_integer_traits<TOML_SMALL_INT_TYPE>
-	{};
-#endif
-
-	// floating-point traits base
-	template <typename T, int MantissaDigits, int DecimalDigits>
-	struct float_traits_base
-	{
-		static constexpr auto type		= node_type::floating_point;
-		using native_type				= double;
-		static constexpr bool is_native = std::is_same_v<T, native_type>;
-		static constexpr bool is_signed = true;
-
-		static constexpr int bits	  = static_cast<int>(sizeof(T) * CHAR_BIT);
-		static constexpr int digits	  = MantissaDigits;
-		static constexpr int digits10 = DecimalDigits;
-
-		static constexpr bool is_losslessly_convertible_to_native = bits <= 64		//
-																 && digits <= 53	// DBL_MANT_DIG
-																 && digits10 <= 15; // DBL_DIG
-
-		static constexpr bool can_represent_native = digits >= 53	 // DBL_MANT_DIG
-												  && digits10 >= 15; // DBL_DIG
-
-		static constexpr bool can_partially_represent_native = digits > 0 && digits10 > 0;
-	};
-	template <typename T>
-	struct float_traits : float_traits_base<T, std::numeric_limits<T>::digits, std::numeric_limits<T>::digits10>
-	{};
-#if TOML_ENABLE_FLOAT16
-	template <>
-	struct float_traits<_Float16> : float_traits_base<_Float16, __FLT16_MANT_DIG__, __FLT16_DIG__>
-	{};
-#endif
-#ifdef TOML_FLOAT128
-	template <>
-	struct float_traits<TOML_FLOAT128> : float_traits_base<TOML_FLOAT128, __FLT128_MANT_DIG__, __FLT128_DIG__>
-	{};
-#endif
-
-	// floating-point traits
-	template <>
-	struct value_traits<float> : float_traits<float>
-	{};
-	template <>
-	struct value_traits<double> : float_traits<double>
-	{};
-	template <>
-	struct value_traits<long double> : float_traits<long double>
-	{};
-#if TOML_ENABLE_FLOAT16
-	template <>
-	struct value_traits<_Float16> : float_traits<_Float16>
-	{};
-#endif
-#ifdef TOML_FLOAT128
-	template <>
-	struct value_traits<TOML_FLOAT128> : float_traits<TOML_FLOAT128>
-	{};
-#endif
-#ifdef TOML_SMALL_FLOAT_TYPE
-	template <>
-	struct value_traits<TOML_SMALL_FLOAT_TYPE> : float_traits<TOML_SMALL_FLOAT_TYPE>
-	{};
-#endif
-	static_assert(value_traits<double>::is_native);
-	static_assert(value_traits<double>::is_losslessly_convertible_to_native);
-	static_assert(value_traits<double>::can_represent_native);
-	static_assert(value_traits<double>::can_partially_represent_native);
-
-	// string value_traits specializations - char-based strings
-	template <typename T>
-	struct string_traits
-	{
-		using native_type										  = std::string;
-		static constexpr bool is_native							  = std::is_same_v<T, native_type>;
-		static constexpr bool is_losslessly_convertible_to_native = true;
-		static constexpr bool can_represent_native =
-			!std::is_array_v<T> && (!std::is_pointer_v<T> || std::is_const_v<std::remove_pointer_t<T>>);
-		static constexpr bool can_partially_represent_native = can_represent_native;
-		static constexpr auto type							 = node_type::string;
-	};
-	template <>
-	struct value_traits<std::string> : string_traits<std::string>
-	{};
-	template <>
-	struct value_traits<std::string_view> : string_traits<std::string_view>
-	{};
-	template <>
-	struct value_traits<const char*> : string_traits<const char*>
-	{};
-	template <size_t N>
-	struct value_traits<const char[N]> : string_traits<const char[N]>
-	{};
-	template <>
-	struct value_traits<char*> : string_traits<char*>
-	{};
-	template <size_t N>
-	struct value_traits<char[N]> : string_traits<char[N]>
-	{};
-
-	// string value_traits specializations - char8_t-based strings
-#if TOML_HAS_CHAR8
-	template <>
-	struct value_traits<std::u8string> : string_traits<std::u8string>
-	{};
-	template <>
-	struct value_traits<std::u8string_view> : string_traits<std::u8string_view>
-	{};
-	template <>
-	struct value_traits<const char8_t*> : string_traits<const char8_t*>
-	{};
-	template <size_t N>
-	struct value_traits<const char8_t[N]> : string_traits<const char8_t[N]>
-	{};
-	template <>
-	struct value_traits<char8_t*> : string_traits<char8_t*>
-	{};
-	template <size_t N>
-	struct value_traits<char8_t[N]> : string_traits<char8_t[N]>
-	{};
-#endif
-
-	// string value_traits specializations - wchar_t-based strings on Windows
-#if TOML_ENABLE_WINDOWS_COMPAT
-	template <typename T>
-	struct wstring_traits
-	{
-		using native_type										  = std::string;
-		static constexpr bool is_native							  = false;
-		static constexpr bool is_losslessly_convertible_to_native = true;							 // narrow
-		static constexpr bool can_represent_native				  = std::is_same_v<T, std::wstring>; // widen
-		static constexpr bool can_partially_represent_native	  = can_represent_native;
-		static constexpr auto type								  = node_type::string;
-	};
-	template <>
-	struct value_traits<std::wstring> : wstring_traits<std::wstring>
-	{};
-	template <>
-	struct value_traits<std::wstring_view> : wstring_traits<std::wstring_view>
-	{};
-	template <>
-	struct value_traits<const wchar_t*> : wstring_traits<const wchar_t*>
-	{};
-	template <size_t N>
-	struct value_traits<const wchar_t[N]> : wstring_traits<const wchar_t[N]>
-	{};
-	template <>
-	struct value_traits<wchar_t*> : wstring_traits<wchar_t*>
-	{};
-	template <size_t N>
-	struct value_traits<wchar_t[N]> : wstring_traits<wchar_t[N]>
-	{};
-#endif
-
-	// other 'native' value_traits specializations
-	template <typename T, node_type NodeType>
-	struct native_value_traits
-	{
-		using native_type										  = T;
-		static constexpr bool is_native							  = true;
-		static constexpr bool is_losslessly_convertible_to_native = true;
-		static constexpr bool can_represent_native				  = true;
-		static constexpr bool can_partially_represent_native	  = true;
-		static constexpr auto type								  = NodeType;
-	};
-	template <>
-	struct value_traits<bool> : native_value_traits<bool, node_type::boolean>
-	{};
-	template <>
-	struct value_traits<date> : native_value_traits<date, node_type::date>
-	{};
-	template <>
-	struct value_traits<time> : native_value_traits<time, node_type::time>
-	{};
-	template <>
-	struct value_traits<date_time> : native_value_traits<date_time, node_type::date_time>
-	{};
-
-	// native value category queries
-	template <typename T>
-	using native_type_of = typename value_traits<T>::native_type;
-	template <typename T>
-	inline constexpr bool is_native = value_traits<T>::is_native;
-	template <typename T>
-	inline constexpr bool can_represent_native = value_traits<T>::can_represent_native;
-	template <typename T>
-	inline constexpr bool can_partially_represent_native = value_traits<T>::can_partially_represent_native;
-	template <typename T>
-	inline constexpr bool is_losslessly_convertible_to_native = value_traits<T>::is_losslessly_convertible_to_native;
-	template <typename T, typename... U>
-	inline constexpr bool is_natively_one_of = is_one_of<native_type_of<T>, U...>;
-
-	// native value types => nodes
-	template <typename T>
-	struct node_wrapper
-	{
-		using type = T;
-	};
-	template <typename T>
-	struct node_wrapper<const T>
-	{
-		using type = std::add_const_t<typename node_wrapper<T>::type>;
-	};
-	template <typename T>
-	struct node_wrapper<volatile T>
-	{
-		using type = std::add_volatile_t<typename node_wrapper<T>::type>;
-	};
-	template <typename T>
-	struct node_wrapper<const volatile T>
-	{
-		using type = std::add_const_t<std::add_volatile_t<typename node_wrapper<T>::type>>;
-	};
-	template <>
-	struct node_wrapper<std::string>
-	{
-		using type = value<std::string>;
-	};
-	template <>
-	struct node_wrapper<int64_t>
-	{
-		using type = value<int64_t>;
-	};
-	template <>
-	struct node_wrapper<double>
-	{
-		using type = value<double>;
-	};
-	template <>
-	struct node_wrapper<bool>
-	{
-		using type = value<bool>;
-	};
-	template <>
-	struct node_wrapper<date>
-	{
-		using type = value<date>;
-	};
-	template <>
-	struct node_wrapper<time>
-	{
-		using type = value<time>;
-	};
-	template <>
-	struct node_wrapper<date_time>
-	{
-		using type = value<date_time>;
-	};
-	template <typename T>
-	using wrap_node = typename node_wrapper<std::remove_reference_t<T>>::type;
-
-	// nodes => native value types
-	template <typename T>
-	struct node_unwrapper
-	{
-		using type = T;
-	};
-	template <typename T>
-	struct node_unwrapper<value<T>>
-	{
-		using type = T;
-	};
-	template <typename T>
-	struct node_unwrapper<const value<T>>
-	{
-		using type = std::add_const_t<T>;
-	};
-	template <typename T>
-	struct node_unwrapper<volatile value<T>>
-	{
-		using type = std::add_volatile_t<T>;
-	};
-	template <typename T>
-	struct node_unwrapper<const volatile value<T>>
-	{
-		using type = std::add_volatile_t<std::add_const_t<T>>;
-	};
-	template <typename T>
-	using unwrap_node = typename node_unwrapper<std::remove_reference_t<T>>::type;
-
-	template <typename T>
-	struct node_type_getter
-	{
-		static constexpr auto value = value_traits<T>::type;
-	};
-	template <>
-	struct node_type_getter<table>
-	{
-		static constexpr auto value = node_type::table;
-	};
-	template <>
-	struct node_type_getter<array>
-	{
-		static constexpr auto value = node_type::array;
-	};
-	template <>
-	struct node_type_getter<void>
-	{
-		static constexpr auto value = node_type::none;
-	};
-	template <typename T>
-	inline constexpr node_type node_type_of = node_type_getter<unwrap_node<remove_cvref<T>>>::value;
-
-	template <typename T, typename ConvertFrom>
-	inline constexpr bool is_constructible_or_convertible = std::is_constructible_v<T, ConvertFrom> //
-														 || std::is_convertible_v<ConvertFrom, T>;
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	template <typename T>
-	inline constexpr bool is_table = std::is_same_v<impl::remove_cvref<T>, table>;
-
-	template <typename T>
-	inline constexpr bool is_array = std::is_same_v<impl::remove_cvref<T>, array>;
-
-	template <typename T>
-	inline constexpr bool is_container = is_table<T> || is_array<T>;
-
-	template <typename T>
-	inline constexpr bool is_string = std::is_same_v<				//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<std::string>>;
-
-	template <typename T>
-	inline constexpr bool is_integer = std::is_same_v<				//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<int64_t>>;
-
-	template <typename T>
-	inline constexpr bool is_floating_point = std::is_same_v<		//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<double>>;
-
-	template <typename T>
-	inline constexpr bool is_number = is_integer<T> || is_floating_point<T>;
-
-	template <typename T>
-	inline constexpr bool is_boolean = std::is_same_v<				//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<bool>>;
-
-	template <typename T>
-	inline constexpr bool is_date = std::is_same_v<					//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<date>>;
-
-	template <typename T>
-	inline constexpr bool is_time = std::is_same_v<					//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<time>>;
-
-	template <typename T>
-	inline constexpr bool is_date_time = std::is_same_v<			//
-		impl::remove_cvref<impl::wrap_node<impl::remove_cvref<T>>>, //
-		value<date_time>>;
-
-	template <typename T>
-	inline constexpr bool is_chronological = is_date<T> || is_time<T> || is_date_time<T>;
-
-	template <typename T>
-	inline constexpr bool is_value = is_string<T> || is_number<T> || is_boolean<T> || is_chronological<T>;
-
-	template <typename T>
-	inline constexpr bool is_node = std::is_same_v<toml::node, impl::remove_cvref<T>> //
-								 || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
-
-	template <typename T>
-	inline constexpr bool is_node_view = impl::is_one_of<impl::remove_cvref<T>, node_view<node>, node_view<const node>>;
-}
-TOML_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <typename T>
-	TOML_CONST_INLINE_GETTER
-	constexpr std::underlying_type_t<T> unwrap_enum(T val) noexcept
-	{
-		return static_cast<std::underlying_type_t<T>>(val);
-	}
-
-	// Q: "why not use std::fpclassify?"
-	// A: Because it gets broken by -ffast-math and friends
-	enum class TOML_CLOSED_ENUM fp_class : unsigned
-	{
-		ok,
-		neg_inf,
-		pos_inf,
-		nan
-	};
-
-	TOML_PURE_GETTER
-	inline fp_class fpclassify(const double& val) noexcept
-	{
-		static_assert(sizeof(uint64_t) == sizeof(double));
-
-		static constexpr uint64_t sign	   = 0b1000000000000000000000000000000000000000000000000000000000000000ull;
-		static constexpr uint64_t exponent = 0b0111111111110000000000000000000000000000000000000000000000000000ull;
-		static constexpr uint64_t mantissa = 0b0000000000001111111111111111111111111111111111111111111111111111ull;
-
-		uint64_t val_bits;
-		std::memcpy(&val_bits, &val, sizeof(val));
-		if ((val_bits & exponent) != exponent)
-			return fp_class::ok;
-		if ((val_bits & mantissa))
-			return fp_class::nan;
-		return (val_bits & sign) ? fp_class::neg_inf : fp_class::pos_inf;
-	}
-
-	// Q: "why not use std::find and std::min?"
-	// A: Because <algorithm> is _huge_ and these would be the only things I used from it.
-	//    I don't want to impose such a heavy compile-time burden on users.
-
-	template <typename Iterator, typename T>
-	TOML_PURE_GETTER
-	inline auto find(Iterator start, Iterator end, const T& needle) noexcept //
-		->decltype(&(*start))
-	{
-		for (; start != end; start++)
-			if (*start == needle)
-				return &(*start);
-		return nullptr;
-	}
-
-	template <typename T>
-	TOML_PURE_INLINE_GETTER
-	constexpr const T& min(const T& a, const T& b) noexcept //
-	{
-		return a < b ? a : b;
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/print_to_stream.h  ************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	// Q: "why does print_to_stream() exist? why not just use ostream::write(), ostream::put() etc?"
-	// A: - I'm using <charconv> to format numerics. Faster and locale-independent.
-	//    - I can (potentially) avoid forcing users to drag in <sstream> and <iomanip>.
-	//    - Strings in C++. Honestly.
-
-	TOML_EXPORTED_FREE_FUNCTION
-	TOML_ATTR(nonnull)
-	void TOML_CALLCONV print_to_stream(std::ostream&, const char*, size_t);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, std::string_view);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const std::string&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, char);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, signed char, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, signed short, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, signed int, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, signed long, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, signed long long, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, unsigned char, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, unsigned short, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, unsigned int, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, unsigned long, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, unsigned long long, value_flags = {}, size_t min_digits = 0);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, float, value_flags = {}, bool relaxed_precision = false);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, double, value_flags = {}, bool relaxed_precision = false);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, bool);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const toml::date&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const toml::time&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const toml::time_offset&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const toml::date_time&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const source_position&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const source_region&);
-
-#if TOML_ENABLE_FORMATTERS
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const array&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const table&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<std::string>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<int64_t>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<double>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<bool>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<date>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<time>&);
-
-	TOML_EXPORTED_FREE_FUNCTION
-	void TOML_CALLCONV print_to_stream(std::ostream&, const value<date_time>&);
-
-#endif
-
-	template <typename T, typename U>
-	inline void print_to_stream_bookended(std::ostream & stream, const T& val, const U& bookend)
-	{
-		print_to_stream(stream, bookend);
-		print_to_stream(stream, val);
-		print_to_stream(stream, bookend);
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/source_region.h  **************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	using source_index = uint32_t;
-
-	using source_path_ptr = std::shared_ptr<const std::string>;
-
-	struct TOML_TRIVIAL_ABI source_position
-	{
-		source_index line;
-
-		source_index column;
-
-		TOML_PURE_GETTER
-		explicit constexpr operator bool() const noexcept
-		{
-			return line > source_index{} //
-				&& column > source_index{};
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator==(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return lhs.line == rhs.line //
-				&& lhs.column == rhs.column;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator!=(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return !(lhs == rhs);
-		}
-
-	  private:
-
-		TOML_PURE_GETTER
-		static constexpr uint64_t pack(const source_position& pos) noexcept
-		{
-			return static_cast<uint64_t>(pos.line) << 32 | static_cast<uint64_t>(pos.column);
-		}
-
-	  public:
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return pack(lhs) < pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<=(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return pack(lhs) <= pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return pack(lhs) > pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>=(const source_position& lhs, const source_position& rhs) noexcept
-		{
-			return pack(lhs) >= pack(rhs);
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const source_position& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-
-	struct source_region
-	{
-		source_position begin;
-
-		source_position end;
-
-		source_path_ptr path;
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		optional<std::wstring> wide_path() const
-		{
-			if (!path || path->empty())
-				return {};
-			return { impl::widen(*path) };
-		}
-
-#endif
-
-		friend std::ostream& operator<<(std::ostream& lhs, const source_region& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/date_time.h  ******************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	struct TOML_TRIVIAL_ABI date
-	{
-		uint16_t year;
-
-		uint8_t month;
-
-		uint8_t day;
-
-		TOML_NODISCARD_CTOR
-		date() noexcept = default;
-
-		TOML_CONSTRAINED_TEMPLATE((impl::all_integral<Y, M, D>), typename Y, typename M, typename D)
-		TOML_NODISCARD_CTOR
-		constexpr date(Y y, M m, D d) noexcept //
-			: year{ static_cast<uint16_t>(y) },
-			  month{ static_cast<uint8_t>(m) },
-			  day{ static_cast<uint8_t>(d) }
-		{}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator==(const date& lhs, const date& rhs) noexcept
-		{
-			return lhs.year == rhs.year	  //
-				&& lhs.month == rhs.month //
-				&& lhs.day == rhs.day;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator!=(const date& lhs, const date& rhs) noexcept
-		{
-			return !(lhs == rhs);
-		}
-
-	  private:
-
-		TOML_PURE_GETTER
-		static constexpr uint32_t pack(const date& d) noexcept
-		{
-			return (static_cast<uint32_t>(d.year) << 16) | (static_cast<uint32_t>(d.month) << 8)
-				 | static_cast<uint32_t>(d.day);
-		}
-
-	  public:
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<(const date& lhs, const date& rhs) noexcept
-		{
-			return pack(lhs) < pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<=(const date& lhs, const date& rhs) noexcept
-		{
-			return pack(lhs) <= pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>(const date& lhs, const date& rhs) noexcept
-		{
-			return pack(lhs) > pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>=(const date& lhs, const date& rhs) noexcept
-		{
-			return pack(lhs) >= pack(rhs);
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const date& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-
-	struct TOML_TRIVIAL_ABI time
-	{
-		uint8_t hour;
-
-		uint8_t minute;
-
-		uint8_t second;
-
-		uint32_t nanosecond;
-
-		TOML_NODISCARD_CTOR
-		time() noexcept = default;
-
-		TOML_CONSTRAINED_TEMPLATE((impl::all_integral<H, M, S, NS>),
-								  typename H,
-								  typename M,
-								  typename S  = uint8_t,
-								  typename NS = uint32_t)
-		TOML_NODISCARD_CTOR
-		constexpr time(H h, M m, S s = S{}, NS ns = NS{}) noexcept //
-			: hour{ static_cast<uint8_t>(h) },
-			  minute{ static_cast<uint8_t>(m) },
-			  second{ static_cast<uint8_t>(s) },
-			  nanosecond{ static_cast<uint32_t>(ns) }
-		{}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator==(const time& lhs, const time& rhs) noexcept
-		{
-			return lhs.hour == rhs.hour		//
-				&& lhs.minute == rhs.minute //
-				&& lhs.second == rhs.second //
-				&& lhs.nanosecond == rhs.nanosecond;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator!=(const time& lhs, const time& rhs) noexcept
-		{
-			return !(lhs == rhs);
-		}
-
-	  private:
-
-		TOML_PURE_GETTER
-		static constexpr uint64_t pack(const time& t) noexcept
-		{
-			return static_cast<uint64_t>(t.hour) << 48 | static_cast<uint64_t>(t.minute) << 40
-				 | static_cast<uint64_t>(t.second) << 32 | static_cast<uint64_t>(t.nanosecond);
-		}
-
-	  public:
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<(const time& lhs, const time& rhs) noexcept
-		{
-			return pack(lhs) < pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<=(const time& lhs, const time& rhs) noexcept
-		{
-			return pack(lhs) <= pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>(const time& lhs, const time& rhs) noexcept
-		{
-			return pack(lhs) > pack(rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator>=(const time& lhs, const time& rhs) noexcept
-		{
-			return pack(lhs) >= pack(rhs);
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const time& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-
-	struct TOML_TRIVIAL_ABI time_offset
-	{
-		int16_t minutes;
-
-		TOML_NODISCARD_CTOR
-		time_offset() noexcept = default;
-
-		TOML_CONSTRAINED_TEMPLATE((impl::all_integral<H, M>), typename H, typename M)
-		TOML_NODISCARD_CTOR
-		constexpr time_offset(H h, M m) noexcept //
-			: minutes{ static_cast<int16_t>(static_cast<impl::common_signed_type<H, M>>(h)
-												* impl::common_signed_type<H, M>{ 60 }
-											+ static_cast<impl::common_signed_type<H, M>>(m)) }
-		{}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator==(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes == rhs.minutes;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator!=(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes != rhs.minutes;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator<(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes < rhs.minutes;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator<=(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes <= rhs.minutes;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator>(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes > rhs.minutes;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator>=(time_offset lhs, time_offset rhs) noexcept
-		{
-			return lhs.minutes >= rhs.minutes;
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const time_offset& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-
-	TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt);
-
-	struct date_time
-	{
-		toml::date date;
-
-		toml::time time;
-
-		optional<toml::time_offset> offset;
-
-		TOML_NODISCARD_CTOR
-		date_time() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		constexpr date_time(const toml::date& d, const toml::time& t) noexcept //
-			: date{ d },
-			  time{ t },
-			  offset{} // TINAE - icc bugfix
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit constexpr date_time(const toml::date& d) noexcept //
-			: date{ d },
-			  time{},
-			  offset{} // TINAE - icc bugfix
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit constexpr date_time(const toml::time& t) noexcept //
-			: date{},
-			  time{ t },
-			  offset{} // TINAE - icc bugfix
-		{}
-
-		TOML_NODISCARD_CTOR
-		constexpr date_time(const toml::date& d, const toml::time& t, const toml::time_offset& off) noexcept
-			: date{ d },
-			  time{ t },
-			  offset{ off }
-		{}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool is_local() const noexcept
-		{
-			return !offset.has_value();
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator==(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			return lhs.date == rhs.date //
-				&& lhs.time == rhs.time //
-				&& lhs.offset == rhs.offset;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator!=(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			return !(lhs == rhs);
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			if (lhs.date != rhs.date)
-				return lhs.date < rhs.date;
-			if (lhs.time != rhs.time)
-				return lhs.time < rhs.time;
-			return lhs.offset < rhs.offset;
-		}
-
-		TOML_PURE_GETTER
-		friend constexpr bool operator<=(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			if (lhs.date != rhs.date)
-				return lhs.date < rhs.date;
-			if (lhs.time != rhs.time)
-				return lhs.time < rhs.time;
-			return lhs.offset <= rhs.offset;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator>(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			return !(lhs <= rhs);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend constexpr bool operator>=(const date_time& lhs, const date_time& rhs) noexcept
-		{
-			return !(lhs < rhs);
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const date_time& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-	};
-
-	TOML_ABI_NAMESPACE_END; // TOML_HAS_CUSTOM_OPTIONAL_TYPE
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/at_path.h  ********************************************************************************************
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <typename T>
-	using parse_path_callback = bool(TOML_CALLCONV*)(void*, T);
-
-	TOML_NODISCARD
-	bool TOML_CALLCONV parse_path(std::string_view,
-								  void*,
-								  parse_path_callback<std::string_view>,
-								  parse_path_callback<size_t>);
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<node> TOML_CALLCONV at_path(node & root, std::string_view path) noexcept;
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<const node> TOML_CALLCONV at_path(const node& root, std::string_view path) noexcept;
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<node> TOML_CALLCONV at_path(node & root, std::wstring_view path);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<const node> TOML_CALLCONV at_path(const node& root, std::wstring_view path);
-
-#endif
-}
-TOML_NAMESPACE_END;
-
-//********  impl/std_vector.h  *****************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <vector>
-#include <iterator>
-TOML_ENABLE_WARNINGS;
-
-//********  impl/path.h  ***********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	enum class TOML_CLOSED_ENUM path_component_type : uint8_t
-	{
-		key			= 0x1,
-		array_index = 0x2
-	};
-
-	class TOML_EXPORTED_CLASS path_component
-	{
-		struct storage_t
-		{
-			static constexpr size_t size =
-				(sizeof(size_t) < sizeof(std::string) ? sizeof(std::string) : sizeof(size_t));
-			static constexpr size_t align =
-				(alignof(size_t) < alignof(std::string) ? alignof(std::string) : alignof(size_t));
-
-			alignas(align) unsigned char bytes[size];
-		};
-		alignas(storage_t::align) mutable storage_t value_storage_;
-
-		path_component_type type_;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_STATIC_FUNCTION
-		static bool TOML_CALLCONV equal(const path_component&, const path_component&) noexcept;
-
-		template <typename Type>
-		TOML_PURE_INLINE_GETTER
-		static Type* get_as(storage_t& s) noexcept
-		{
-			return TOML_LAUNDER(reinterpret_cast<Type*>(s.bytes));
-		}
-
-		static void store_key(std::string_view key, storage_t& storage_)
-		{
-			::new (static_cast<void*>(storage_.bytes)) std::string{ key };
-		}
-
-		static void store_index(size_t index, storage_t& storage_) noexcept
-		{
-			::new (static_cast<void*>(storage_.bytes)) std::size_t{ index };
-		}
-
-		void destroy() noexcept
-		{
-			if (type_ == path_component_type::key)
-				get_as<std::string>(value_storage_)->~basic_string();
-		}
-
-		TOML_NODISCARD
-		size_t& index_ref() noexcept
-		{
-			TOML_ASSERT_ASSUME(type_ == path_component_type::array_index);
-			return *get_as<size_t>(value_storage_);
-		}
-
-		TOML_NODISCARD
-		std::string& key_ref() noexcept
-		{
-			TOML_ASSERT_ASSUME(type_ == path_component_type::key);
-			return *get_as<std::string>(value_storage_);
-		}
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component();
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component(size_t index) noexcept;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component(std::string_view key);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component(std::wstring_view key);
-
-#endif
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component(const path_component& pc);
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component(path_component&& pc) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component& operator=(const path_component& rhs);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component& operator=(path_component&& rhs) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component& operator=(size_t new_index) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component& operator=(std::string_view new_key);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path_component& operator=(std::wstring_view new_key);
-
-#endif
-
-		~path_component() noexcept
-		{
-			destroy();
-		}
-
-		TOML_PURE_GETTER
-		size_t index() const noexcept
-		{
-			TOML_ASSERT_ASSUME(type_ == path_component_type::array_index);
-			return *get_as<const size_t>(value_storage_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator size_t() const noexcept
-		{
-			return index();
-		}
-
-		TOML_PURE_GETTER
-		const std::string& key() const noexcept
-		{
-			TOML_ASSERT_ASSUME(type_ == path_component_type::key);
-			return *get_as<const std::string>(value_storage_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator const std::string&() const noexcept
-		{
-			return key();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		path_component_type type() const noexcept
-		{
-			return type_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const path_component& lhs, const path_component& rhs) noexcept
-		{
-			return equal(lhs, rhs);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const path_component& lhs, const path_component& rhs) noexcept
-		{
-			return !equal(lhs, rhs);
-		}
-	};
-
-	class TOML_EXPORTED_CLASS path
-	{
-	  private:
-
-		std::vector<path_component> components_;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_to(std::ostream&) const;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_STATIC_FUNCTION
-		static bool TOML_CALLCONV equal(const path&, const path&) noexcept;
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		path() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		explicit path(std::string_view);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		explicit path(std::wstring_view);
-
-#endif
-
-		~path() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		path(const path&) = default;
-
-		TOML_NODISCARD_CTOR
-		path(path&&) noexcept = default;
-
-		TOML_PURE_INLINE_GETTER
-		size_t size() const noexcept
-		{
-			return components_.size();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator bool() const noexcept
-		{
-			return !components_.empty();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool empty() const noexcept
-		{
-			return components_.empty();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		path_component& operator[](size_t index) noexcept
-		{
-			TOML_ASSERT(index < size());
-			return components_[index];
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const path_component& operator[](size_t index) const noexcept
-		{
-			TOML_ASSERT(index < size());
-			return components_[index];
-		}
-
-		path& operator=(const path&) = default;
-
-		path& operator=(path&&) noexcept = default;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator=(std::string_view);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator=(std::wstring_view);
-
-#endif
-
-		TOML_ALWAYS_INLINE
-		path& assign(const path& p)
-		{
-			return *this = p;
-		}
-
-		TOML_ALWAYS_INLINE
-		path& assign(path&& p) noexcept
-		{
-			return *this = std::move(p);
-		}
-
-		TOML_ALWAYS_INLINE
-		path& assign(std::string_view str)
-		{
-			return *this = str;
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_ALWAYS_INLINE
-		path& assign(std::wstring_view str)
-		{
-			return *this = str;
-		}
-
-#endif
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator+=(const path&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator+=(path&&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator+=(std::string_view);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& operator+=(std::wstring_view);
-
-#endif
-
-		TOML_ALWAYS_INLINE
-		path& append(const path& p)
-		{
-			return *this += p;
-		}
-
-		TOML_ALWAYS_INLINE
-		path& append(path&& p)
-		{
-			return *this += std::move(p);
-		}
-
-		TOML_ALWAYS_INLINE
-		path& append(std::string_view str)
-		{
-			return *this += str;
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_ALWAYS_INLINE
-		path& append(std::wstring_view str)
-		{
-			return *this += str;
-		}
-
-#endif
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& prepend(const path&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& prepend(path&&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& prepend(std::string_view);
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& prepend(std::wstring_view);
-
-#endif
-
-		TOML_NODISCARD
-		friend path operator+(const path& lhs, const path& rhs)
-		{
-			path result = lhs;
-			result += rhs;
-			return result;
-		}
-
-		TOML_NODISCARD
-		friend path operator+(const path& lhs, std::string_view rhs)
-		{
-			path result = lhs;
-			result += rhs;
-			return result;
-		}
-
-		TOML_NODISCARD
-		friend path operator+(std::string_view lhs, const path& rhs)
-		{
-			path result = rhs;
-			result.prepend(lhs);
-			return result;
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		friend path operator+(const path& lhs, std::wstring_view rhs)
-		{
-			path result = lhs;
-			result += rhs;
-			return result;
-		}
-
-		TOML_NODISCARD
-		friend path operator+(std::wstring_view lhs, const path& rhs)
-		{
-			path result = rhs;
-			result.prepend(lhs);
-			return result;
-		}
-
-#endif
-
-		TOML_ALWAYS_INLINE
-		friend std::ostream& operator<<(std::ostream& os, const path& rhs)
-		{
-			rhs.print_to(os);
-			return os;
-		}
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		std::string str() const;
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		explicit operator std::string() const
-		{
-			return str();
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		std::wstring wide_str() const;
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		explicit operator std::wstring() const
-		{
-			return wide_str();
-		}
-
-#endif
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const path& lhs, const path& rhs) noexcept
-		{
-			return equal(lhs, rhs);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const path& lhs, const path& rhs) noexcept
-		{
-			return !equal(lhs, rhs);
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator==(const path& lhs, std::string_view rhs)
-		{
-			return lhs == path{ rhs };
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator==(std::string_view lhs, const path& rhs)
-		{
-			return rhs == lhs;
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator!=(const path& lhs, std::string_view rhs)
-		{
-			return lhs != path{ rhs };
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator!=(std::string_view lhs, const path& rhs)
-		{
-			return rhs != lhs;
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator==(const path& lhs, std::wstring_view rhs)
-		{
-			return lhs == path{ rhs };
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator==(std::wstring_view lhs, const path& rhs)
-		{
-			return rhs == lhs;
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator!=(const path& lhs, std::wstring_view rhs)
-		{
-			return lhs != path{ rhs };
-		}
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		friend bool operator!=(std::wstring_view lhs, const path& rhs)
-		{
-			return rhs != lhs;
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		using iterator = std::vector<path_component>::iterator;
-
-		using const_iterator = std::vector<path_component>::const_iterator;
-
-		TOML_PURE_INLINE_GETTER
-		iterator begin() noexcept
-		{
-			return components_.begin();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		iterator end() noexcept
-		{
-			return components_.end();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator begin() const noexcept
-		{
-			return components_.begin();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator end() const noexcept
-		{
-			return components_.end();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator cbegin() const noexcept
-		{
-			return components_.begin();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator cend() const noexcept
-		{
-			return components_.end();
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void clear() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path& truncate(size_t n);
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path truncated(size_t n) const;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path parent() const;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path leaf(size_t n = 1) const;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path subpath(const_iterator start, const_iterator end) const;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		path subpath(size_t start, size_t length) const;
-	};
-
-	inline namespace literals
-	{
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		path operator"" _tpath(const char* str, size_t len)
-		{
-			return path(std::string_view{ str, len });
-		}
-	}
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept;
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept;
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/std_utility.h  ****************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <utility>
-TOML_ENABLE_WARNINGS;
-
-//********  impl/node.h  ***********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	class TOML_ABSTRACT_INTERFACE TOML_EXPORTED_CLASS node
-	{
-	  private:
-
-		friend class TOML_PARSER_TYPENAME;
-		source_region source_{};
-
-		template <typename T>
-		TOML_NODISCARD
-		decltype(auto) get_value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		template <typename T, typename N>
-		using ref_type_ = std::conditional_t<													//
-			std::is_reference_v<T>,																//
-			impl::copy_ref<impl::copy_cv<impl::unwrap_node<T>, std::remove_reference_t<N>>, T>, //
-			impl::copy_cvref<impl::unwrap_node<T>, N>											//
-			>;
-
-		template <typename T, typename N>
-		using ref_type = std::conditional_t<			 //
-			std::is_reference_v<N>,						 //
-			ref_type_<T, N>,							 //
-			ref_type_<T, std::add_lvalue_reference_t<N>> //
-			>;
-
-		template <typename T, typename N>
-		TOML_PURE_GETTER
-		static ref_type<T, N&&> do_ref(N&& n) noexcept
-		{
-			using unwrapped_type = impl::unwrap_node<T>;
-			static_assert(toml::is_value<unwrapped_type> || toml::is_container<unwrapped_type>,
-						  "The template type argument of node::ref() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			TOML_ASSERT_ASSUME(
-				n.template is<unwrapped_type>()
-				&& "template type argument provided to toml::node::ref() didn't match the node's actual type");
-
-			using node_ref = std::remove_volatile_t<std::remove_reference_t<N>>&;
-			using val_type = std::remove_volatile_t<unwrapped_type>;
-			using out_ref  = ref_type<T, N&&>;
-			static_assert(std::is_reference_v<out_ref>);
-
-			if constexpr (toml::is_value<unwrapped_type>)
-				return static_cast<out_ref>(const_cast<node_ref>(n).template ref_cast<val_type>().get());
-			else
-				return static_cast<out_ref>(const_cast<node_ref>(n).template ref_cast<val_type>());
-		}
-
-	  protected:
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node(const node&) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node(node&&) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node& operator=(const node&) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node& operator=(node&&) noexcept;
-
-		template <typename T, typename N>
-		using ref_cast_type_ = std::conditional_t<											  //
-			std::is_reference_v<T>,															  //
-			impl::copy_ref<impl::copy_cv<impl::wrap_node<T>, std::remove_reference_t<N>>, T>, //
-			impl::copy_cvref<impl::wrap_node<T>, N>											  //
-			>;
-
-		template <typename T, typename N>
-		using ref_cast_type = std::conditional_t<			  //
-			std::is_reference_v<N>,							  //
-			ref_cast_type_<T, N>,							  //
-			ref_cast_type_<T, std::add_lvalue_reference_t<N>> //
-			>;
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		ref_cast_type<T, node&> ref_cast() & noexcept
-		{
-			using out_ref  = ref_cast_type<T, node&>;
-			using out_type = std::remove_reference_t<out_ref>;
-			return static_cast<out_ref>(*reinterpret_cast<out_type*>(this));
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		ref_cast_type<T, node&&> ref_cast() && noexcept
-		{
-			using out_ref  = ref_cast_type<T, node&&>;
-			using out_type = std::remove_reference_t<out_ref>;
-			return static_cast<out_ref>(*reinterpret_cast<out_type*>(this));
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		ref_cast_type<T, const node&> ref_cast() const& noexcept
-		{
-			using out_ref  = ref_cast_type<T, const node&>;
-			using out_type = std::remove_reference_t<out_ref>;
-			return static_cast<out_ref>(*reinterpret_cast<out_type*>(this));
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		ref_cast_type<T, const node&&> ref_cast() const&& noexcept
-		{
-			using out_ref  = ref_cast_type<T, const node&&>;
-			using out_type = std::remove_reference_t<out_ref>;
-			return static_cast<out_ref>(*reinterpret_cast<out_type*>(this));
-		}
-
-	  public:
-		TOML_EXPORTED_MEMBER_FUNCTION
-		virtual ~node() noexcept;
-
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype) const noexcept = 0;
-
-		template <typename ElemType = void>
-		TOML_PURE_GETTER
-		bool is_homogeneous() const noexcept
-		{
-			using type = impl::remove_cvref<impl::unwrap_node<ElemType>>;
-			static_assert(std::is_void_v<type> || toml::is_value<type> || toml::is_container<type>,
-						  "The template type argument of node::is_homogeneous() must be void or one "
-						  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			return is_homogeneous(impl::node_type_of<type>);
-		}
-
-		TOML_PURE_GETTER
-		virtual node_type type() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_table() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_array() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_array_of_tables() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_value() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_string() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_integer() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_floating_point() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_number() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_boolean() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_date() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_time() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual bool is_date_time() const noexcept = 0;
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		bool is() const noexcept
-		{
-			using type = impl::remove_cvref<impl::unwrap_node<T>>;
-			static_assert(toml::is_value<type> || toml::is_container<type>,
-						  "The template type argument of node::is() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			if constexpr (std::is_same_v<type, table>)
-				return is_table();
-			else if constexpr (std::is_same_v<type, array>)
-				return is_array();
-			else if constexpr (std::is_same_v<type, std::string>)
-				return is_string();
-			else if constexpr (std::is_same_v<type, int64_t>)
-				return is_integer();
-			else if constexpr (std::is_same_v<type, double>)
-				return is_floating_point();
-			else if constexpr (std::is_same_v<type, bool>)
-				return is_boolean();
-			else if constexpr (std::is_same_v<type, date>)
-				return is_date();
-			else if constexpr (std::is_same_v<type, time>)
-				return is_time();
-			else if constexpr (std::is_same_v<type, date_time>)
-				return is_date_time();
-		}
-
-		TOML_PURE_GETTER
-		virtual table* as_table() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual array* as_array() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<std::string>* as_string() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<int64_t>* as_integer() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<double>* as_floating_point() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<bool>* as_boolean() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<date>* as_date() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<time>* as_time() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual toml::value<date_time>* as_date_time() noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const table* as_table() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const array* as_array() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<std::string>* as_string() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<int64_t>* as_integer() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<double>* as_floating_point() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<bool>* as_boolean() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<date>* as_date() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<time>* as_time() const noexcept = 0;
-
-		TOML_PURE_GETTER
-		virtual const toml::value<date_time>* as_date_time() const noexcept = 0;
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		impl::wrap_node<T>* as() noexcept
-		{
-			using unwrapped_type = impl::unwrap_node<impl::remove_cvref<T>>;
-			static_assert(toml::is_value<unwrapped_type> || toml::is_container<unwrapped_type>,
-						  "The template type argument of node::as() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			if constexpr (std::is_same_v<unwrapped_type, table>)
-				return as_table();
-			else if constexpr (std::is_same_v<unwrapped_type, array>)
-				return as_array();
-			else if constexpr (std::is_same_v<unwrapped_type, std::string>)
-				return as_string();
-			else if constexpr (std::is_same_v<unwrapped_type, int64_t>)
-				return as_integer();
-			else if constexpr (std::is_same_v<unwrapped_type, double>)
-				return as_floating_point();
-			else if constexpr (std::is_same_v<unwrapped_type, bool>)
-				return as_boolean();
-			else if constexpr (std::is_same_v<unwrapped_type, date>)
-				return as_date();
-			else if constexpr (std::is_same_v<unwrapped_type, time>)
-				return as_time();
-			else if constexpr (std::is_same_v<unwrapped_type, date_time>)
-				return as_date_time();
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		const impl::wrap_node<T>* as() const noexcept
-		{
-			using unwrapped_type = impl::unwrap_node<impl::remove_cvref<T>>;
-			static_assert(toml::is_value<unwrapped_type> || toml::is_container<unwrapped_type>,
-						  "The template type argument of node::as() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			if constexpr (std::is_same_v<unwrapped_type, table>)
-				return as_table();
-			else if constexpr (std::is_same_v<unwrapped_type, array>)
-				return as_array();
-			else if constexpr (std::is_same_v<unwrapped_type, std::string>)
-				return as_string();
-			else if constexpr (std::is_same_v<unwrapped_type, int64_t>)
-				return as_integer();
-			else if constexpr (std::is_same_v<unwrapped_type, double>)
-				return as_floating_point();
-			else if constexpr (std::is_same_v<unwrapped_type, bool>)
-				return as_boolean();
-			else if constexpr (std::is_same_v<unwrapped_type, date>)
-				return as_date();
-			else if constexpr (std::is_same_v<unwrapped_type, time>)
-				return as_time();
-			else if constexpr (std::is_same_v<unwrapped_type, date_time>)
-				return as_date_time();
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value() const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		template <typename T>
-		TOML_NODISCARD
-		auto value_or(T&& default_value) const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() & noexcept
-		{
-			return do_ref<T>(*this);
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() && noexcept
-		{
-			return do_ref<T>(std::move(*this));
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() const& noexcept
-		{
-			return do_ref<T>(*this);
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() const&& noexcept
-		{
-			return do_ref<T>(std::move(*this));
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const source_region& source() const noexcept
-		{
-			return source_;
-		}
-
-	  private:
-
-		template <typename Func, typename Node, typename T>
-		static constexpr bool can_visit = std::is_invocable_v<Func, ref_cast_type<T, Node>>;
-
-		template <typename Func, typename Node, typename T>
-		static constexpr bool can_visit_nothrow = std::is_nothrow_invocable_v<Func, ref_cast_type<T, Node>>;
-
-		template <typename Func, typename Node>
-		static constexpr bool can_visit_any = can_visit<Func, Node, table>		 //
-										   || can_visit<Func, Node, array>		 //
-										   || can_visit<Func, Node, std::string> //
-										   || can_visit<Func, Node, int64_t>	 //
-										   || can_visit<Func, Node, double>		 //
-										   || can_visit<Func, Node, bool>		 //
-										   || can_visit<Func, Node, date>		 //
-										   || can_visit<Func, Node, time>		 //
-										   || can_visit<Func, Node, date_time>;
-
-		// clang-format off
-
-		template <typename Func, typename Node>
-		static constexpr bool can_visit_all = can_visit<Func, Node, table>		 //
-										   && can_visit<Func, Node, array>		 //
-										   && can_visit<Func, Node, std::string> //
-										   && can_visit<Func, Node, int64_t>	 //
-										   && can_visit<Func, Node, double>		 //
-										   && can_visit<Func, Node, bool>		 //
-										   && can_visit<Func, Node, date>		 //
-										   && can_visit<Func, Node, time>		 //
-										   && can_visit<Func, Node, date_time>;
-
-		template <typename Func, typename Node, typename T>
-		static constexpr bool visit_is_nothrow_one = !can_visit<Func, Node, T> || can_visit_nothrow<Func, Node, T>;
-
-		template <typename Func, typename Node>
-		static constexpr bool visit_is_nothrow = visit_is_nothrow_one<Func, Node, table>	   //
-											  && visit_is_nothrow_one<Func, Node, array>	   //
-											  && visit_is_nothrow_one<Func, Node, std::string> //
-											  && visit_is_nothrow_one<Func, Node, int64_t>	   //
-											  && visit_is_nothrow_one<Func, Node, double>	   //
-											  && visit_is_nothrow_one<Func, Node, bool>		   //
-											  && visit_is_nothrow_one<Func, Node, date>		   //
-											  && visit_is_nothrow_one<Func, Node, time>		   //
-											  && visit_is_nothrow_one<Func, Node, date_time>;
-
-		// clang-format on
-
-		template <typename Func, typename Node, typename T, bool = can_visit<Func, Node, T>>
-		struct visit_return_type_
-		{
-			using type = decltype(std::declval<Func>()(std::declval<ref_cast_type<T, Node>>()));
-		};
-		template <typename Func, typename Node, typename T>
-		struct visit_return_type_<Func, Node, T, false>
-		{
-			using type = void;
-		};
-
-		template <typename Func, typename Node, typename T>
-		using visit_return_type = typename visit_return_type_<Func, Node, T>::type;
-
-		template <typename A, typename B>
-		using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
-
-		template <typename Func, typename Node>
-		static decltype(auto) do_visit(Func&& visitor, Node&& n) noexcept(visit_is_nothrow<Func&&, Node&&>)
-		{
-			static_assert(can_visit_any<Func&&, Node&&>,
-						  "TOML node visitors must be invocable for at least one of the toml::node "
-						  "specializations:" TOML_SA_NODE_TYPE_LIST);
-
-			switch (n.type())
-			{
-				case node_type::table:
-					if constexpr (can_visit<Func&&, Node&&, table>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<table>());
-					break;
-
-				case node_type::array:
-					if constexpr (can_visit<Func&&, Node&&, array>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<array>());
-					break;
-
-				case node_type::string:
-					if constexpr (can_visit<Func&&, Node&&, std::string>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<std::string>());
-					break;
-
-				case node_type::integer:
-					if constexpr (can_visit<Func&&, Node&&, int64_t>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<int64_t>());
-					break;
-
-				case node_type::floating_point:
-					if constexpr (can_visit<Func&&, Node&&, double>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<double>());
-					break;
-
-				case node_type::boolean:
-					if constexpr (can_visit<Func&&, Node&&, bool>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<bool>());
-					break;
-
-				case node_type::date:
-					if constexpr (can_visit<Func&&, Node&&, date>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date>());
-					break;
-
-				case node_type::time:
-					if constexpr (can_visit<Func&&, Node&&, time>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<time>());
-					break;
-
-				case node_type::date_time:
-					if constexpr (can_visit<Func&&, Node&&, date_time>)
-						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date_time>());
-					break;
-
-				case node_type::none: TOML_UNREACHABLE;
-				default: TOML_UNREACHABLE;
-			}
-
-			if constexpr (!can_visit_all<Func&&, Node&&>)
-			{
-				// clang-format off
-
-				using return_type =
-					nonvoid<visit_return_type<Func&&, Node&&, table>,
-					nonvoid<visit_return_type<Func&&, Node&&, array>,
-					nonvoid<visit_return_type<Func&&, Node&&, std::string>,
-					nonvoid<visit_return_type<Func&&, Node&&, int64_t>,
-					nonvoid<visit_return_type<Func&&, Node&&, double>,
-					nonvoid<visit_return_type<Func&&, Node&&, bool>,
-					nonvoid<visit_return_type<Func&&, Node&&, date>,
-					nonvoid<visit_return_type<Func&&, Node&&, time>,
-							visit_return_type<Func&&, Node&&, date_time>
-				>>>>>>>>;
-
-				// clang-format on
-
-				if constexpr (!std::is_void_v<return_type>)
-				{
-					static_assert(std::is_default_constructible_v<return_type>,
-								  "Non-exhaustive visitors must return a default-constructible type, or void");
-					return return_type{};
-				}
-			}
-		}
-
-	  public:
-
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) & noexcept(visit_is_nothrow<Func&&, node&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), *this);
-		}
-
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) && noexcept(visit_is_nothrow<Func&&, node&&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), static_cast<node&&>(*this));
-		}
-
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) const& noexcept(visit_is_nothrow<Func&&, const node&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), *this);
-		}
-
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) const&& noexcept(visit_is_nothrow<Func&&, const node&&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), static_cast<const node&&>(*this));
-		}
-
-		TOML_NODISCARD
-		explicit operator node_view<node>() noexcept;
-
-		TOML_NODISCARD
-		explicit operator node_view<const node>() const noexcept;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(std::string_view path) noexcept;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(std::string_view path) const noexcept;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(const toml::path& path) noexcept;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(const toml::path& path) const noexcept;
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(std::wstring_view path);
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(std::wstring_view path) const;
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> operator[](const toml::path& path) noexcept;
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> operator[](const toml::path& path) const noexcept;
-	};
-}
-TOML_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_PURE_GETTER
-	TOML_EXPORTED_FREE_FUNCTION
-	bool TOML_CALLCONV node_deep_equality(const node*, const node*) noexcept;
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/std_initializer_list.h  *******************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <initializer_list>
-TOML_ENABLE_WARNINGS;
-
-//********  impl/node_view.h  ******************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_DISABLE_ARITHMETIC_WARNINGS;
-
-TOML_NAMESPACE_START
-{
-	template <typename ViewedType>
-	class TOML_TRIVIAL_ABI node_view
-	{
-		static_assert(impl::is_one_of<ViewedType, toml::node, const toml::node>,
-					  "A toml::node_view<> must wrap toml::node or const toml::node.");
-
-	  public:
-
-		using viewed_type = ViewedType;
-
-	  private:
-		template <typename T>
-		friend class node_view;
-
-		mutable viewed_type* node_ = nullptr;
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		node_view() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		explicit node_view(viewed_type* node) noexcept //
-			: node_{ node }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit node_view(viewed_type& node) noexcept //
-			: node_{ &node }
-		{}
-
-		TOML_NODISCARD_CTOR
-		node_view(const node_view&) noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		node_view(node_view&&) noexcept = default;
-
-		node_view& operator=(const node_view&) & noexcept = default;
-
-		node_view& operator=(node_view&&) & noexcept = default;
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator bool() const noexcept
-		{
-			return node_ != nullptr;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		viewed_type* node() const noexcept
-		{
-			return node_;
-		}
-
-		TOML_PURE_GETTER
-		node_type type() const noexcept
-		{
-			return node_ ? node_->type() : node_type::none;
-		}
-
-		TOML_PURE_GETTER
-		bool is_table() const noexcept
-		{
-			return node_ && node_->is_table();
-		}
-
-		TOML_PURE_GETTER
-		bool is_array() const noexcept
-		{
-			return node_ && node_->is_array();
-		}
-
-		TOML_PURE_GETTER
-		bool is_value() const noexcept
-		{
-			return node_ && node_->is_value();
-		}
-
-		TOML_PURE_GETTER
-		bool is_string() const noexcept
-		{
-			return node_ && node_->is_string();
-		}
-
-		TOML_PURE_GETTER
-		bool is_integer() const noexcept
-		{
-			return node_ && node_->is_integer();
-		}
-
-		TOML_PURE_GETTER
-		bool is_floating_point() const noexcept
-		{
-			return node_ && node_->is_floating_point();
-		}
-
-		TOML_PURE_GETTER
-		bool is_number() const noexcept
-		{
-			return node_ && node_->is_number();
-		}
-
-		TOML_PURE_GETTER
-		bool is_boolean() const noexcept
-		{
-			return node_ && node_->is_boolean();
-		}
-
-		TOML_PURE_GETTER
-		bool is_date() const noexcept
-		{
-			return node_ && node_->is_date();
-		}
-
-		TOML_PURE_GETTER
-		bool is_time() const noexcept
-		{
-			return node_ && node_->is_time();
-		}
-
-		TOML_PURE_GETTER
-		bool is_date_time() const noexcept
-		{
-			return node_ && node_->is_date_time();
-		}
-
-		TOML_PURE_GETTER
-		bool is_array_of_tables() const noexcept
-		{
-			return node_ && node_->is_array_of_tables();
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		bool is() const noexcept
-		{
-			return node_ ? node_->template is<impl::unwrap_node<impl::remove_cvref<T>>>() : false;
-		}
-
-		TOML_NODISCARD
-		bool is_homogeneous(node_type ntype, viewed_type*& first_nonmatch) const noexcept
-		{
-			if (!node_)
-			{
-				first_nonmatch = {};
-				return false;
-			}
-			return node_->is_homogeneous(ntype, first_nonmatch);
-		}
-
-		TOML_NODISCARD
-		bool is_homogeneous(node_type ntype) const noexcept
-		{
-			return node_ ? node_->is_homogeneous(ntype) : false;
-		}
-
-		template <typename ElemType = void>
-		TOML_PURE_GETTER
-		bool is_homogeneous() const noexcept
-		{
-			return node_ ? node_->template is_homogeneous<impl::unwrap_node<impl::remove_cvref<ElemType>>>() : false;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		auto* as() const noexcept
-		{
-			return node_ ? node_->template as<T>() : nullptr;
-		}
-
-		TOML_PURE_GETTER
-		auto* as_table() const noexcept
-		{
-			return as<table>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_array() const noexcept
-		{
-			return as<array>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_string() const noexcept
-		{
-			return as<std::string>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_integer() const noexcept
-		{
-			return as<int64_t>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_floating_point() const noexcept
-		{
-			return as<double>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_boolean() const noexcept
-		{
-			return as<bool>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_date() const noexcept
-		{
-			return as<date>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_time() const noexcept
-		{
-			return as<time>();
-		}
-
-		TOML_PURE_GETTER
-		auto* as_date_time() const noexcept
-		{
-			return as<date_time>();
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>)
-		{
-			if (node_)
-				return node_->template value_exact<T>();
-			return {};
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value() const noexcept(impl::value_retrieval_is_nothrow<T>)
-		{
-			if (node_)
-				return node_->template value<T>();
-			return {};
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		auto value_or(T&& default_value) const noexcept(impl::value_retrieval_is_nothrow<T>)
-		{
-			using namespace ::toml::impl;
-
-			static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Retrieving values as wide-character strings is only "
-						  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			if constexpr (is_wide_string<T>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-				if (node_)
-					return node_->value_or(static_cast<T&&>(default_value));
-				return std::wstring{ static_cast<T&&>(default_value) };
-
-#else
-
-				static_assert(impl::dependent_false<T>, "Evaluated unreachable branch!");
-
-#endif
-			}
-			else
-			{
-				using value_type =
-					std::conditional_t<std::is_pointer_v<std::decay_t<T>>,
-									   std::add_pointer_t<std::add_const_t<std::remove_pointer_t<std::decay_t<T>>>>,
-									   std::decay_t<T>>;
-
-				if (node_)
-					return node_->value_or(static_cast<T&&>(default_value));
-				if constexpr (std::is_pointer_v<value_type>)
-					return value_type{ default_value };
-				else
-					return static_cast<T&&>(default_value);
-			}
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		decltype(auto) ref() const noexcept
-		{
-			TOML_ASSERT_ASSUME(node_ && "toml::node_view::ref() called on a node_view that did not reference a node");
-			return node_->template ref<T>();
-		}
-
-	  private:
-
-		template <typename Func>
-		static constexpr bool visit_is_nothrow = noexcept(std::declval<viewed_type*>()->visit(std::declval<Func>()));
-
-	  public:
-
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) const noexcept(visit_is_nothrow<Func&&>)
-		{
-			using return_type = decltype(node_->visit(static_cast<Func&&>(visitor)));
-			if (node_)
-				return node_->visit(static_cast<Func&&>(visitor));
-			if constexpr (!std::is_void_v<return_type>)
-				return return_type{};
-		}
-
-	  public:
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator==(const node_view& lhs, const node_view<T>& rhs) noexcept
-		{
-			return impl::node_deep_equality(lhs.node_, rhs.node_);
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator!=(const node_view& lhs, const node_view<T>& rhs) noexcept
-		{
-			return !impl::node_deep_equality(lhs.node_, rhs.node_);
-		}
-
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs, const table& rhs) noexcept
-		{
-			if (lhs.node_ == &rhs)
-				return true;
-			const auto tbl = lhs.as<table>();
-			return tbl && *tbl == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const table&, );
-
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs, const array& rhs) noexcept
-		{
-			if (lhs.node_ == &rhs)
-				return true;
-			const auto arr = lhs.as<array>();
-			return arr && *arr == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const array&, );
-
-		template <typename T>
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs, const toml::value<T>& rhs) noexcept
-		{
-			if (lhs.node_ == &rhs)
-				return true;
-			const auto val = lhs.as<T>();
-			return val && *val == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const toml::value<T>&, template <typename T>);
-
-		TOML_CONSTRAINED_TEMPLATE(impl::is_losslessly_convertible_to_native<T>, typename T)
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs, const T& rhs) noexcept(!impl::is_wide_string<T>)
-		{
-			static_assert(!impl::is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Comparison with wide-character strings is only "
-						  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			if constexpr (impl::is_wide_string<T>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return lhs == impl::narrow(rhs);
-#else
-				static_assert(impl::dependent_false<T>, "Evaluated unreachable branch!");
-#endif
-			}
-			else
-			{
-				const auto val = lhs.as<impl::native_type_of<T>>();
-				return val && *val == rhs;
-			}
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&,
-									   const T&,
-									   TOML_CONSTRAINED_TEMPLATE(impl::is_losslessly_convertible_to_native<T>,
-																 typename T));
-
-		template <typename T>
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs,
-							   const std::initializer_list<T>& rhs) noexcept(!impl::is_wide_string<T>)
-		{
-			const auto arr = lhs.as<array>();
-			return arr && *arr == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const std::initializer_list<T>&, template <typename T>);
-
-		template <typename T>
-		TOML_NODISCARD
-		friend bool operator==(const node_view& lhs, const std::vector<T>& rhs) noexcept(!impl::is_wide_string<T>)
-		{
-			const auto arr = lhs.as<array>();
-			return arr && *arr == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const std::vector<T>&, template <typename T>);
-
-		TOML_NODISCARD
-		node_view operator[](std::string_view key) const noexcept
-		{
-			if (auto tbl = this->as_table())
-				return node_view{ tbl->get(key) };
-			return {};
-		}
-
-		TOML_NODISCARD
-		node_view operator[](const toml::path& path) const noexcept
-		{
-			return node_ ? node_->at_path(path) : node_view{};
-		}
-
-		TOML_NODISCARD
-		node_view at_path(std::string_view path) const noexcept
-		{
-			return node_ ? node_->at_path(path) : node_view{};
-		}
-
-		TOML_NODISCARD
-		node_view at_path(const toml::path& path) const noexcept
-		{
-			return node_ ? node_->at_path(path) : node_view{};
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node_view operator[](std::wstring_view key) const
-		{
-			if (auto tbl = this->as_table())
-				return node_view{ tbl->get(key) };
-			return {};
-		}
-
-		TOML_NODISCARD
-		node_view at_path(std::wstring_view path) const
-		{
-			return node_ ? node_->at_path(path) : node_view{};
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node_view operator[](size_t index) const noexcept
-		{
-			if (auto arr = this->as_array())
-				return node_view{ arr->get(index) };
-			return {};
-		}
-
-#if TOML_ENABLE_FORMATTERS
-
-		friend std::ostream& operator<<(std::ostream& os, const node_view& nv)
-		{
-			if (nv.node_)
-				nv.node_->visit([&os](const auto& n) { os << n; });
-			return os;
-		}
-
-#endif
-	};
-
-	template <typename T>
-	node_view(const T&) -> node_view<const node>;
-
-	template <typename T>
-	node_view(const T*) -> node_view<const node>;
-
-	template <typename T>
-	node_view(T&) -> node_view<node>;
-
-	template <typename T>
-	node_view(T*) -> node_view<node>;
-}
-TOML_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	inline node::operator node_view<node>() noexcept
-	{
-		return node_view<node>{ this };
-	}
-
-	inline node::operator node_view<const node>() const noexcept
-	{
-		return node_view<const node>{ this };
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/value.h  **********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_DISABLE_ARITHMETIC_WARNINGS;
-
-// clang-format off
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-	#define TOML_SA_VALUE_MESSAGE_WSTRING			TOML_SA_LIST_SEP "std::wstring"
-#else
-	#define TOML_SA_VALUE_MESSAGE_WSTRING
-#endif
-#if TOML_HAS_CHAR8
-	#define TOML_SA_VALUE_MESSAGE_U8STRING_VIEW		TOML_SA_LIST_SEP "std::u8string_view"
-	#define TOML_SA_VALUE_MESSAGE_CONST_CHAR8		TOML_SA_LIST_SEP "const char8_t*"
-#else
-	#define TOML_SA_VALUE_MESSAGE_U8STRING_VIEW
-	#define TOML_SA_VALUE_MESSAGE_CONST_CHAR8
-#endif
-
-#define TOML_SA_VALUE_EXACT_FUNC_MESSAGE(type_arg)															\
-	"The " type_arg " must be one of:"																		\
-	TOML_SA_LIST_NEW "A native TOML value type"																\
-	TOML_SA_NATIVE_VALUE_TYPE_LIST																			\
-																											\
-	TOML_SA_LIST_NXT "A non-view type capable of losslessly representing a native TOML value type"			\
-	TOML_SA_LIST_BEG "std::string"																			\
-	TOML_SA_VALUE_MESSAGE_WSTRING																			\
-	TOML_SA_LIST_SEP "any signed integer type >= 64 bits"													\
-	TOML_SA_LIST_SEP "any floating-point type >= 64 bits"													\
-	TOML_SA_LIST_END																						\
-																											\
-	TOML_SA_LIST_NXT "An immutable view type not requiring additional temporary storage"					\
-	TOML_SA_LIST_BEG "std::string_view"																		\
-	TOML_SA_VALUE_MESSAGE_U8STRING_VIEW																		\
-	TOML_SA_LIST_SEP "const char*"																			\
-	TOML_SA_VALUE_MESSAGE_CONST_CHAR8																		\
-		TOML_SA_LIST_END
-
-#define TOML_SA_VALUE_FUNC_MESSAGE(type_arg)																\
-	"The " type_arg " must be one of:"																		\
-	TOML_SA_LIST_NEW "A native TOML value type"																\
-	TOML_SA_NATIVE_VALUE_TYPE_LIST																			\
-																											\
-	TOML_SA_LIST_NXT "A non-view type capable of losslessly representing a native TOML value type"			\
-	TOML_SA_LIST_BEG "std::string"																			\
-	TOML_SA_VALUE_MESSAGE_WSTRING																			\
-	TOML_SA_LIST_SEP "any signed integer type >= 64 bits"													\
-	TOML_SA_LIST_SEP "any floating-point type >= 64 bits"													\
-	TOML_SA_LIST_END																						\
-																											\
-	TOML_SA_LIST_NXT "A non-view type capable of (reasonably) representing a native TOML value type"		\
-	TOML_SA_LIST_BEG "any other integer type"																\
-	TOML_SA_LIST_SEP "any floating-point type"																\
-	TOML_SA_LIST_END																						\
-																											\
-	TOML_SA_LIST_NXT "An immutable view type not requiring additional temporary storage"					\
-	TOML_SA_LIST_BEG "std::string_view"																		\
-	TOML_SA_VALUE_MESSAGE_U8STRING_VIEW																		\
-	TOML_SA_LIST_SEP "const char*"																			\
-	TOML_SA_VALUE_MESSAGE_CONST_CHAR8																		\
-	TOML_SA_LIST_END
-
-// clang-format on
-TOML_IMPL_NAMESPACE_START
-{
-	template <typename T, typename...>
-	struct native_value_maker
-	{
-		template <typename... Args>
-		TOML_NODISCARD
-		static T make(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args&&...>)
-		{
-			if constexpr (std::is_aggregate_v<T>)
-				return T{ static_cast<Args&&>(args)... };
-			else
-				return T(static_cast<Args&&>(args)...);
-		}
-	};
-
-	template <typename T>
-	struct native_value_maker<T, T>
-	{
-		template <typename U>
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		static U&& make(U&& val) noexcept
-		{
-			return static_cast<U&&>(val);
-		}
-	};
-
-#if TOML_HAS_CHAR8 || TOML_ENABLE_WINDOWS_COMPAT
-
-	struct string_maker
-	{
-		template <typename T>
-		TOML_NODISCARD
-		static std::string make(T&& arg) noexcept
-		{
-			using arg_type = std::decay_t<T>;
-#if TOML_HAS_CHAR8
-			if constexpr (is_one_of<arg_type, char8_t*, const char8_t*>)
-			{
-				return std::string(reinterpret_cast<const char*>(static_cast<const char8_t*>(arg)));
-			}
-			if constexpr (is_one_of<arg_type, std::u8string, std::u8string_view>)
-			{
-				return std::string(reinterpret_cast<const char*>(static_cast<const char8_t*>(arg.data())),
-								   arg.length());
-			}
-#endif
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-			if constexpr (is_wide_string<arg_type>)
-			{
-				return narrow(static_cast<T&&>(arg));
-			}
-#endif
-		}
-	};
-
-#if TOML_HAS_CHAR8
-	template <>
-	struct native_value_maker<std::string, char8_t*> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, const char8_t*> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, std::u8string> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, std::u8string_view> : string_maker
-	{};
-#endif // TOML_HAS_CHAR8
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-	template <>
-	struct native_value_maker<std::string, wchar_t*> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, const wchar_t*> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, std::wstring> : string_maker
-	{};
-	template <>
-	struct native_value_maker<std::string, std::wstring_view> : string_maker
-	{};
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-#endif // TOML_HAS_CHAR8 || TOML_ENABLE_WINDOWS_COMPAT
-
-	template <typename T>
-	TOML_CONST_GETTER
-	inline optional<T> node_integer_cast(int64_t val) noexcept
-	{
-		static_assert(node_type_of<T> == node_type::integer);
-		static_assert(!is_cvref<T>);
-
-		using traits = value_traits<T>;
-		if constexpr (!traits::is_signed)
-		{
-			if constexpr ((sizeof(T) * CHAR_BIT) < 63) // 63 bits == int64_max
-			{
-				using common_t = decltype(int64_t{} + T{});
-				if (val < int64_t{} || static_cast<common_t>(val) > static_cast<common_t>(traits::max))
-					return {};
-			}
-			else
-			{
-				if (val < int64_t{})
-					return {};
-			}
-		}
-		else
-		{
-			if (val < traits::min || val > traits::max)
-				return {};
-		}
-		return { static_cast<T>(val) };
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	template <typename ValueType>
-	class value : public node
-	{
-		static_assert(impl::is_native<ValueType> && !impl::is_cvref<ValueType>,
-					  "A toml::value<> must model one of the native TOML value types:" TOML_SA_NATIVE_VALUE_TYPE_LIST);
-
-	  private:
-
-		friend class TOML_PARSER_TYPENAME;
-
-		template <typename T, typename U>
-		TOML_CONST_INLINE_GETTER
-		static auto as_value([[maybe_unused]] U* ptr) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return ptr;
-			else
-				return nullptr;
-		}
-
-		ValueType val_;
-		value_flags flags_ = value_flags::none;
-
-	  public:
-
-		using value_type = ValueType;
-
-		using value_arg = POXY_IMPLEMENTATION_DETAIL(
-			std::conditional_t<
-				std::is_same_v<value_type, std::string>,
-				std::string_view,
-				std::conditional_t<impl::is_one_of<value_type, double, int64_t, bool>, value_type, const value_type&>>);
-
-		template <typename... Args>
-		TOML_NODISCARD_CTOR
-		explicit value(Args&&... args) noexcept(noexcept(value_type(
-			impl::native_value_maker<value_type, std::decay_t<Args>...>::make(static_cast<Args&&>(args)...))))
-			: val_(impl::native_value_maker<value_type, std::decay_t<Args>...>::make(static_cast<Args&&>(args)...))
-		{
-#if TOML_LIFETIME_HOOKS
-			TOML_VALUE_CREATED;
-#endif
-		}
-
-		TOML_NODISCARD_CTOR
-		value(const value& other) noexcept //
-			: node(other),
-			  val_{ other.val_ },
-			  flags_{ other.flags_ }
-		{
-#if TOML_LIFETIME_HOOKS
-			TOML_VALUE_CREATED;
-#endif
-		}
-
-		TOML_NODISCARD_CTOR
-		value(const value& other, value_flags flags) noexcept //
-			: node(other),
-			  val_{ other.val_ },
-			  flags_{ flags == preserve_source_value_flags ? other.flags_ : flags }
-		{
-#if TOML_LIFETIME_HOOKS
-			TOML_VALUE_CREATED;
-#endif
-		}
-
-		TOML_NODISCARD_CTOR
-		value(value&& other) noexcept //
-			: node(std::move(other)),
-			  val_{ std::move(other.val_) },
-			  flags_{ other.flags_ }
-		{
-#if TOML_LIFETIME_HOOKS
-			TOML_VALUE_CREATED;
-#endif
-		}
-
-		TOML_NODISCARD_CTOR
-		value(value&& other, value_flags flags) noexcept //
-			: node(std::move(other)),
-			  val_{ std::move(other.val_) },
-			  flags_{ flags == preserve_source_value_flags ? other.flags_ : flags }
-		{
-#if TOML_LIFETIME_HOOKS
-			TOML_VALUE_CREATED;
-#endif
-		}
-
-		value& operator=(const value& rhs) noexcept
-		{
-			node::operator=(rhs);
-			val_   = rhs.val_;
-			flags_ = rhs.flags_;
-			return *this;
-		}
-
-		value& operator=(value&& rhs) noexcept
-		{
-			if (&rhs != this)
-			{
-				node::operator=(std::move(rhs));
-				val_   = std::move(rhs.val_);
-				flags_ = rhs.flags_;
-			}
-			return *this;
-		}
-
-#if TOML_LIFETIME_HOOKS
-		~value() noexcept
-		{
-			TOML_VALUE_DESTROYED;
-		}
-#endif
-
-		TOML_CONST_INLINE_GETTER
-		node_type type() const noexcept final
-		{
-			return impl::node_type_of<value_type>;
-		}
-
-		TOML_PURE_GETTER
-		bool is_homogeneous(node_type ntype) const noexcept final
-		{
-			return ntype == node_type::none || ntype == impl::node_type_of<value_type>;
-		}
-
-		TOML_PURE_GETTER
-		bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept final
-		{
-			if (ntype != node_type::none && ntype != impl::node_type_of<value_type>)
-			{
-				first_nonmatch = this;
-				return false;
-			}
-			return true;
-		}
-
-		TOML_PURE_GETTER
-		bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept final
-		{
-			if (ntype != node_type::none && ntype != impl::node_type_of<value_type>)
-			{
-				first_nonmatch = this;
-				return false;
-			}
-			return true;
-		}
-
-		template <typename ElemType = void>
-		TOML_PURE_GETTER
-		bool is_homogeneous() const noexcept
-		{
-			using type = impl::remove_cvref<impl::unwrap_node<ElemType>>;
-			static_assert(std::is_void_v<type> || toml::is_value<type> || toml::is_container<type>,
-						  "The template type argument of value::is_homogeneous() must be void or one "
-						  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			if constexpr (std::is_void_v<type>)
-				return true;
-			else
-				return impl::node_type_of<type> == impl::node_type_of<value_type>;
-		}
-		TOML_CONST_INLINE_GETTER
-		bool is_table() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_array() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_array_of_tables() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_value() const noexcept final
-		{
-			return true;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_string() const noexcept final
-		{
-			return std::is_same_v<value_type, std::string>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_integer() const noexcept final
-		{
-			return std::is_same_v<value_type, int64_t>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_floating_point() const noexcept final
-		{
-			return std::is_same_v<value_type, double>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_number() const noexcept final
-		{
-			return impl::is_one_of<value_type, int64_t, double>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_boolean() const noexcept final
-		{
-			return std::is_same_v<value_type, bool>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date() const noexcept final
-		{
-			return std::is_same_v<value_type, date>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_time() const noexcept final
-		{
-			return std::is_same_v<value_type, time>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date_time() const noexcept final
-		{
-			return std::is_same_v<value_type, date_time>;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		table* as_table() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		array* as_array() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<std::string>* as_string() noexcept final
-		{
-			return as_value<std::string>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<int64_t>* as_integer() noexcept final
-		{
-			return as_value<int64_t>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<double>* as_floating_point() noexcept final
-		{
-			return as_value<double>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<bool>* as_boolean() noexcept final
-		{
-			return as_value<bool>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<date>* as_date() noexcept final
-		{
-			return as_value<date>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<time>* as_time() noexcept final
-		{
-			return as_value<time>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		value<date_time>* as_date_time() noexcept final
-		{
-			return as_value<date_time>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const table* as_table() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const array* as_array() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<std::string>* as_string() const noexcept final
-		{
-			return as_value<std::string>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<int64_t>* as_integer() const noexcept final
-		{
-			return as_value<int64_t>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<double>* as_floating_point() const noexcept final
-		{
-			return as_value<double>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<bool>* as_boolean() const noexcept final
-		{
-			return as_value<bool>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<date>* as_date() const noexcept final
-		{
-			return as_value<date>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<time>* as_time() const noexcept final
-		{
-			return as_value<time>(this);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const value<date_time>* as_date_time() const noexcept final
-		{
-			return as_value<date_time>(this);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		value_type& get() & noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		value_type&& get() && noexcept
-		{
-			return static_cast<value_type&&>(val_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const value_type& get() const& noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const value_type&& get() const&& noexcept
-		{
-			return static_cast<const value_type&&>(val_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		value_type& operator*() & noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		value_type&& operator*() && noexcept
-		{
-			return static_cast<value_type&&>(val_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const value_type& operator*() const& noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const value_type&& operator*() const&& noexcept
-		{
-			return static_cast<const value_type&&>(val_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator value_type&() & noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator value_type&&() && noexcept
-		{
-			return static_cast<value_type&&>(val_);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator const value_type&() const& noexcept
-		{
-			return val_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator const value_type&&() && noexcept
-		{
-			return static_cast<const value_type&&>(val_);
-		}
-
-		TOML_HIDDEN_CONSTRAINT(std::is_class_v<T>, typename T = value_type)
-		TOML_PURE_INLINE_GETTER
-		value_type* operator->() noexcept
-		{
-			return &val_;
-		}
-
-		TOML_HIDDEN_CONSTRAINT(std::is_class_v<T>, typename T = value_type)
-		TOML_PURE_INLINE_GETTER
-		const value_type* operator->() const noexcept
-		{
-			return &val_;
-		}
-
-		TOML_NODISCARD
-		value_flags flags() const noexcept
-		{
-			return flags_;
-		}
-
-		value& flags(value_flags new_flags) noexcept
-		{
-			flags_ = new_flags;
-			return *this;
-		}
-
-		value& operator=(value_arg rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, std::string>)
-				val_.assign(rhs);
-			else
-				val_ = rhs;
-			return *this;
-		}
-
-		TOML_CONSTRAINED_TEMPLATE((std::is_same_v<T, std::string>), typename T = value_type)
-		value& operator=(std::string&& rhs) noexcept
-		{
-			val_ = std::move(rhs);
-			return *this;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator==(const value& lhs, value_arg rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, double>)
-			{
-				const auto lhs_nan = impl::fpclassify(lhs.val_) == impl::fp_class::nan;
-				const auto rhs_nan = impl::fpclassify(rhs) == impl::fp_class::nan;
-				if (lhs_nan != rhs_nan)
-					return false;
-				if (lhs_nan)
-					return true;
-			}
-			return lhs.val_ == rhs;
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const value&, value_arg, );
-
-		TOML_PURE_GETTER
-		friend bool operator<(const value& lhs, value_arg rhs) noexcept
-		{
-			return lhs.val_ < rhs;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator<(value_arg lhs, const value& rhs) noexcept
-		{
-			return lhs < rhs.val_;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator<=(const value& lhs, value_arg rhs) noexcept
-		{
-			return lhs.val_ <= rhs;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator<=(value_arg lhs, const value& rhs) noexcept
-		{
-			return lhs <= rhs.val_;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator>(const value& lhs, value_arg rhs) noexcept
-		{
-			return lhs.val_ > rhs;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator>(value_arg lhs, const value& rhs) noexcept
-		{
-			return lhs > rhs.val_;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator>=(const value& lhs, value_arg rhs) noexcept
-		{
-			return lhs.val_ >= rhs;
-		}
-
-		TOML_PURE_GETTER
-		friend bool operator>=(value_arg lhs, const value& rhs) noexcept
-		{
-			return lhs >= rhs.val_;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator==(const value& lhs, const value<T>& rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return lhs == rhs.val_; // calls asymmetrical value-equality operator defined above
-			else
-				return false;
-		}
-
-		template <typename T>
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const value& lhs, const value<T>& rhs) noexcept
-		{
-			return !(lhs == rhs);
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator<(const value& lhs, const value<T>& rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return lhs.val_ < rhs.val_;
-			else
-				return impl::node_type_of<value_type> < impl::node_type_of<T>;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator<=(const value& lhs, const value<T>& rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return lhs.val_ <= rhs.val_;
-			else
-				return impl::node_type_of<value_type> <= impl::node_type_of<T>;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator>(const value& lhs, const value<T>& rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return lhs.val_ > rhs.val_;
-			else
-				return impl::node_type_of<value_type> > impl::node_type_of<T>;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		friend bool operator>=(const value& lhs, const value<T>& rhs) noexcept
-		{
-			if constexpr (std::is_same_v<value_type, T>)
-				return lhs.val_ >= rhs.val_;
-			else
-				return impl::node_type_of<value_type> >= impl::node_type_of<T>;
-		}
-
-#if TOML_ENABLE_FORMATTERS
-
-		friend std::ostream& operator<<(std::ostream& lhs, const value& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-
-#endif
-	};
-
-	template <typename T>
-	value(T) -> value<impl::native_type_of<impl::remove_cvref<T>>>;
-
-	template <typename T>
-	TOML_NODISCARD
-	inline decltype(auto) node::get_value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>)
-	{
-		using namespace impl;
-
-		static_assert(node_type_of<T> != node_type::none);
-		static_assert(node_type_of<T> != node_type::table);
-		static_assert(node_type_of<T> != node_type::array);
-		static_assert(is_native<T> || can_represent_native<T>);
-		static_assert(!is_cvref<T>);
-		TOML_ASSERT(this->type() == node_type_of<T>);
-
-		if constexpr (node_type_of<T> == node_type::string)
-		{
-			const auto& str = *ref_cast<std::string>();
-			if constexpr (std::is_same_v<T, std::string>)
-				return str;
-			else if constexpr (std::is_same_v<T, std::string_view>)
-				return T{ str };
-			else if constexpr (std::is_same_v<T, const char*>)
-				return str.c_str();
-
-			else if constexpr (std::is_same_v<T, std::wstring>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return widen(str);
-#else
-				static_assert(dependent_false<T>, "Evaluated unreachable branch!");
-#endif
-			}
-
-#if TOML_HAS_CHAR8
-
-			// char -> char8_t (potentially unsafe - the feature is 'experimental'!)
-			else if constexpr (is_one_of<T, std::u8string, std::u8string_view>)
-				return T(reinterpret_cast<const char8_t*>(str.c_str()), str.length());
-			else if constexpr (std::is_same_v<T, const char8_t*>)
-				return reinterpret_cast<const char8_t*>(str.c_str());
-			else
-				static_assert(dependent_false<T>, "Evaluated unreachable branch!");
-
-#endif
-		}
-		else
-			return static_cast<T>(*ref_cast<native_type_of<T>>());
-	}
-
-	template <typename T>
-	TOML_NODISCARD
-	inline optional<T> node::value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>)
-	{
-		using namespace impl;
-
-		static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-					  "Retrieving values as wide-character strings with node::value_exact() is only "
-					  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-		static_assert((is_native<T> || can_represent_native<T>)&&!is_cvref<T>,
-					  TOML_SA_VALUE_EXACT_FUNC_MESSAGE("return type of node::value_exact()"));
-
-		// prevent additional compiler error spam when the static_assert fails by gating behind if constexpr
-		if constexpr ((is_native<T> || can_represent_native<T>)&&!is_cvref<T>)
-		{
-			if (type() == node_type_of<T>)
-				return { this->get_value_exact<T>() };
-			else
-				return {};
-		}
-	}
-
-	template <typename T>
-	TOML_NODISCARD
-	inline optional<T> node::value() const noexcept(impl::value_retrieval_is_nothrow<T>)
-	{
-		using namespace impl;
-
-		static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-					  "Retrieving values as wide-character strings with node::value() is only "
-					  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-		static_assert((is_native<T> || can_represent_native<T> || can_partially_represent_native<T>)&&!is_cvref<T>,
-					  TOML_SA_VALUE_FUNC_MESSAGE("return type of node::value()"));
-
-		// when asking for strings, dates, times and date_times there's no 'fuzzy' conversion
-		// semantics to be mindful of so the exact retrieval is enough.
-		if constexpr (is_natively_one_of<T, std::string, time, date, date_time>)
-		{
-			if (type() == node_type_of<T>)
-				return { this->get_value_exact<T>() };
-			else
-				return {};
-		}
-
-		// everything else requires a bit of logicking.
-		else
-		{
-			switch (type())
-			{
-				// int -> *
-				case node_type::integer:
-				{
-					// int -> int
-					if constexpr (is_natively_one_of<T, int64_t>)
-					{
-						if constexpr (is_native<T> || can_represent_native<T>)
-							return static_cast<T>(*ref_cast<int64_t>());
-						else
-							return node_integer_cast<T>(*ref_cast<int64_t>());
-					}
-
-					// int -> float
-					else if constexpr (is_natively_one_of<T, double>)
-					{
-						const int64_t val = *ref_cast<int64_t>();
-						if constexpr (std::numeric_limits<T>::digits < 64)
-						{
-							constexpr auto largest_whole_float = (int64_t{ 1 } << std::numeric_limits<T>::digits);
-							if (val < -largest_whole_float || val > largest_whole_float)
-								return {};
-						}
-						return static_cast<T>(val);
-					}
-
-					// int -> bool
-					else if constexpr (is_natively_one_of<T, bool>)
-						return static_cast<bool>(*ref_cast<int64_t>());
-
-					// int -> anything else
-					else
-						return {};
-				}
-
-				// float -> *
-				case node_type::floating_point:
-				{
-					// float -> float
-					if constexpr (is_natively_one_of<T, double>)
-					{
-						if constexpr (is_native<T> || can_represent_native<T>)
-							return { static_cast<T>(*ref_cast<double>()) };
-						else
-						{
-							const double val = *ref_cast<double>();
-							if (impl::fpclassify(val) == fp_class::ok
-								&& (val < (std::numeric_limits<T>::lowest)() || val > (std::numeric_limits<T>::max)()))
-								return {};
-							return { static_cast<T>(val) };
-						}
-					}
-
-					// float -> int
-					else if constexpr (is_natively_one_of<T, int64_t>)
-					{
-						const double val = *ref_cast<double>();
-						if (impl::fpclassify(val) == fp_class::ok
-							&& static_cast<double>(static_cast<int64_t>(val)) == val)
-							return node_integer_cast<T>(static_cast<int64_t>(val));
-						else
-							return {};
-					}
-
-					// float -> anything else
-					else
-						return {};
-				}
-
-				// bool -> *
-				case node_type::boolean:
-				{
-					// bool -> bool
-					if constexpr (is_natively_one_of<T, bool>)
-						return { *ref_cast<bool>() };
-
-					// bool -> int
-					else if constexpr (is_natively_one_of<T, int64_t>)
-						return { static_cast<T>(*ref_cast<bool>()) };
-
-					// bool -> anything else
-					else
-						return {};
-				}
-			}
-
-			// non-values, or 'exact' types covered above
-			return {};
-		}
-	}
-
-	template <typename T>
-	TOML_NODISCARD
-	inline auto node::value_or(T && default_value) const noexcept(impl::value_retrieval_is_nothrow<T>)
-	{
-		using namespace impl;
-
-		static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-					  "Retrieving values as wide-character strings with node::value_or() is only "
-					  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-		if constexpr (is_wide_string<T>)
-		{
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-			if (type() == node_type::string)
-				return widen(*ref_cast<std::string>());
-			return std::wstring{ static_cast<T&&>(default_value) };
-
-#else
-
-			static_assert(dependent_false<T>, "Evaluated unreachable branch!");
-
-#endif
-		}
-		else
-		{
-			using value_type =
-				std::conditional_t<std::is_pointer_v<std::decay_t<T>>,
-								   std::add_pointer_t<std::add_const_t<std::remove_pointer_t<std::decay_t<T>>>>,
-								   std::decay_t<T>>;
-			using traits = value_traits<value_type>;
-
-			// clang-format off
-
-			static_assert(
-				traits::is_native || traits::can_represent_native || traits::can_partially_represent_native,
-				"The default value type of node::value_or() must be one of:"
-				TOML_SA_LIST_NEW "A native TOML value type"
-				TOML_SA_NATIVE_VALUE_TYPE_LIST
-
-				TOML_SA_LIST_NXT "A non-view type capable of losslessly representing a native TOML value type"
-				TOML_SA_LIST_BEG "std::string"
-				#if TOML_ENABLE_WINDOWS_COMPAT
-				TOML_SA_LIST_SEP "std::wstring"
-				#endif
-				TOML_SA_LIST_SEP "any signed integer type >= 64 bits"
-				TOML_SA_LIST_SEP "any floating-point type >= 64 bits"
-				TOML_SA_LIST_END
-
-				TOML_SA_LIST_NXT "A non-view type capable of (reasonably) representing a native TOML value type"
-				TOML_SA_LIST_BEG "any other integer type"
-				TOML_SA_LIST_SEP "any floating-point type"
-				TOML_SA_LIST_END
-
-				TOML_SA_LIST_NXT "A compatible view type"
-				TOML_SA_LIST_BEG "std::string_view"
-				#if TOML_HAS_CHAR8
-				TOML_SA_LIST_SEP "std::u8string_view"
-				#endif
-				#if TOML_ENABLE_WINDOWS_COMPAT
-				TOML_SA_LIST_SEP "std::wstring_view"
-				#endif
-				TOML_SA_LIST_SEP "const char*"
-				#if TOML_HAS_CHAR8
-				TOML_SA_LIST_SEP "const char8_t*"
-				#endif
-				#if TOML_ENABLE_WINDOWS_COMPAT
-				TOML_SA_LIST_SEP "const wchar_t*"
-				#endif
-				TOML_SA_LIST_END
-			);
-
-			// clang-format on
-
-			// prevent additional compiler error spam when the static_assert fails by gating behind if constexpr
-			if constexpr (traits::is_native || traits::can_represent_native || traits::can_partially_represent_native)
-			{
-				if constexpr (traits::is_native)
-				{
-					if (type() == node_type_of<value_type>)
-						return *ref_cast<typename traits::native_type>();
-				}
-				if (auto val = this->value<value_type>())
-					return *val;
-				if constexpr (std::is_pointer_v<value_type>)
-					return value_type{ default_value };
-				else
-					return static_cast<T&&>(default_value);
-			}
-		}
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/make_node.h  ******************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <typename T>
-	TOML_NODISCARD
-	TOML_ATTR(returns_nonnull)
-	auto* make_node_impl_specialized(T && val, [[maybe_unused]] value_flags flags)
-	{
-		using unwrapped_type = unwrap_node<remove_cvref<T>>;
-		static_assert(!std::is_same_v<unwrapped_type, node>);
-		static_assert(!is_node_view<unwrapped_type>);
-
-		// arrays + tables - invoke copy/move ctor
-		if constexpr (is_one_of<unwrapped_type, array, table>)
-		{
-			return new unwrapped_type(static_cast<T&&>(val));
-		}
-
-		// values
-		else
-		{
-			using native_type = native_type_of<unwrapped_type>;
-			using value_type  = value<native_type>;
-
-			value_type* out;
-
-			// copy/move ctor
-			if constexpr (std::is_same_v<remove_cvref<T>, value_type>)
-			{
-				out = new value_type{ static_cast<T&&>(val) };
-			}
-
-			// creating from raw value
-			else
-			{
-				static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
-							  "Instantiating values from wide-character strings is only "
-							  "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-				if constexpr (!is_losslessly_convertible_to_native<unwrapped_type>)
-				{
-					if constexpr (std::is_same_v<native_type, int64_t>)
-						static_assert(dependent_false<T>,
-									  "Integral value initializers must be losslessly convertible to int64_t");
-					else if constexpr (std::is_same_v<native_type, double>)
-						static_assert(dependent_false<T>,
-									  "Floating-point value initializers must be losslessly convertible to double");
-					else
-						static_assert(
-							dependent_false<T>,
-							"Value initializers must be losslessly convertible to one of the TOML value types");
-				}
-
-				if constexpr (is_wide_string<T>)
-				{
-#if TOML_ENABLE_WINDOWS_COMPAT
-					out = new value_type{ narrow(static_cast<T&&>(val)) };
-#else
-					static_assert(dependent_false<T>, "Evaluated unreachable branch!");
-#endif
-				}
-				else
-					out = new value_type{ static_cast<T&&>(val) };
-			}
-
-			if (flags != preserve_source_value_flags)
-				out->flags(flags);
-
-			return out;
-		}
-	}
-
-	template <typename T>
-	TOML_NODISCARD
-	auto* make_node_impl(T && val, value_flags flags = preserve_source_value_flags)
-	{
-		using unwrapped_type = unwrap_node<remove_cvref<T>>;
-		if constexpr (std::is_same_v<unwrapped_type, node> || is_node_view<unwrapped_type>)
-		{
-			if constexpr (is_node_view<unwrapped_type>)
-			{
-				if (!val)
-					return static_cast<toml::node*>(nullptr);
-			}
-
-			return static_cast<T&&>(val).visit(
-				[flags](auto&& concrete) {
-					return static_cast<toml::node*>(
-						make_node_impl_specialized(static_cast<decltype(concrete)&&>(concrete), flags));
-				});
-		}
-		else
-			return make_node_impl_specialized(static_cast<T&&>(val), flags);
-	}
-
-	template <typename T>
-	TOML_NODISCARD
-	auto* make_node_impl(inserter<T> && val, value_flags flags = preserve_source_value_flags)
-	{
-		return make_node_impl(static_cast<T&&>(val.value), flags);
-	}
-
-	template <typename T, bool = (is_node<T> || is_node_view<T> || is_value<T> || can_partially_represent_native<T>)>
-	struct inserted_type_of_
-	{
-		using type = std::remove_pointer_t<decltype(make_node_impl(std::declval<T>()))>;
-	};
-
-	template <typename T>
-	struct inserted_type_of_<inserter<T>, false>
-	{
-		using type = typename inserted_type_of_<remove_cvref<T>>::type;
-	};
-
-	template <typename T>
-	struct inserted_type_of_<T, false>
-	{
-		using type = void;
-	};
-
-	template <typename T>
-	TOML_NODISCARD
-	node_ptr make_node(T && val, value_flags flags = preserve_source_value_flags)
-	{
-		return node_ptr{ make_node_impl(static_cast<T&&>(val), flags) };
-	}
-
-	template <typename... T>
-	struct emplaced_type_of_
-	{
-		using type = void;
-	};
-
-	template <typename T>
-	struct emplaced_type_of_<T>
-	{
-		using type = std::conditional_t<is_one_of<T, node, node_view<node>, node_view<const node>>,
-										void,
-										typename inserted_type_of_<T>::type>;
-	};
-
-	template <typename T>
-	struct emplaced_type_of_<inserter<T>>
-	{
-		using type = typename emplaced_type_of_<remove_cvref<T>>::type;
-	};
-
-	template <typename... T>
-	using emplaced_type_of = typename emplaced_type_of_<remove_cvref<T>...>::type;
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	template <typename T>
-	using inserted_type_of = POXY_IMPLEMENTATION_DETAIL(typename impl::inserted_type_of_<impl::remove_cvref<T>>::type);
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/array.h  **********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <bool IsConst>
-	class TOML_TRIVIAL_ABI array_iterator
-	{
-	  private:
-		template <bool>
-		friend class array_iterator;
-
-		using mutable_vector_iterator = std::vector<node_ptr>::iterator;
-		using const_vector_iterator	  = std::vector<node_ptr>::const_iterator;
-		using vector_iterator		  = std::conditional_t<IsConst, const_vector_iterator, mutable_vector_iterator>;
-
-		mutable vector_iterator iter_;
-
-	  public:
-		using value_type		= std::conditional_t<IsConst, const node, node>;
-		using reference			= value_type&;
-		using pointer			= value_type*;
-		using difference_type	= ptrdiff_t;
-		using iterator_category = typename std::iterator_traits<vector_iterator>::iterator_category;
-
-		TOML_NODISCARD_CTOR
-		array_iterator() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		explicit array_iterator(mutable_vector_iterator iter) noexcept //
-			: iter_{ iter }
-		{}
-
-		TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
-		TOML_NODISCARD_CTOR
-		explicit array_iterator(const_vector_iterator iter) noexcept //
-			: iter_{ iter }
-		{}
-
-		TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
-		TOML_NODISCARD_CTOR
-		array_iterator(const array_iterator<false>& other) noexcept //
-			: iter_{ other.iter_ }
-		{}
-
-		TOML_NODISCARD_CTOR
-		array_iterator(const array_iterator&) noexcept = default;
-
-		array_iterator& operator=(const array_iterator&) noexcept = default;
-
-		array_iterator& operator++() noexcept // ++pre
-		{
-			++iter_;
-			return *this;
-		}
-
-		array_iterator operator++(int) noexcept // post++
-		{
-			array_iterator out{ iter_ };
-			++iter_;
-			return out;
-		}
-
-		array_iterator& operator--() noexcept // --pre
-		{
-			--iter_;
-			return *this;
-		}
-
-		array_iterator operator--(int) noexcept // post--
-		{
-			array_iterator out{ iter_ };
-			--iter_;
-			return out;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		reference operator*() const noexcept
-		{
-			return *iter_->get();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		pointer operator->() const noexcept
-		{
-			return iter_->get();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator const vector_iterator&() const noexcept
-		{
-			return iter_;
-		}
-
-		TOML_CONSTRAINED_TEMPLATE(!C, bool C = IsConst)
-		TOML_PURE_INLINE_GETTER
-		explicit operator const const_vector_iterator() const noexcept
-		{
-			return iter_;
-		}
-
-		array_iterator& operator+=(ptrdiff_t rhs) noexcept
-		{
-			iter_ += rhs;
-			return *this;
-		}
-
-		array_iterator& operator-=(ptrdiff_t rhs) noexcept
-		{
-			iter_ -= rhs;
-			return *this;
-		}
-
-		TOML_NODISCARD
-		friend array_iterator operator+(const array_iterator& lhs, ptrdiff_t rhs) noexcept
-		{
-			return array_iterator{ lhs.iter_ + rhs };
-		}
-
-		TOML_NODISCARD
-		friend array_iterator operator+(ptrdiff_t lhs, const array_iterator& rhs) noexcept
-		{
-			return array_iterator{ rhs.iter_ + lhs };
-		}
-
-		TOML_NODISCARD
-		friend array_iterator operator-(const array_iterator& lhs, ptrdiff_t rhs) noexcept
-		{
-			return array_iterator{ lhs.iter_ - rhs };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend ptrdiff_t operator-(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ - rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ == rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ != rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ < rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<=(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ <= rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ > rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>=(const array_iterator& lhs, const array_iterator& rhs) noexcept
-		{
-			return lhs.iter_ >= rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		reference operator[](ptrdiff_t idx) const noexcept
-		{
-			return *(iter_ + idx)->get();
-		}
-	};
-
-	struct array_init_elem
-	{
-		mutable node_ptr value;
-
-		template <typename T>
-		TOML_NODISCARD_CTOR
-		array_init_elem(T&& val, value_flags flags = preserve_source_value_flags) //
-			: value{ make_node(static_cast<T&&>(val), flags) }
-		{}
-	};
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	using array_iterator = POXY_IMPLEMENTATION_DETAIL(impl::array_iterator<false>);
-
-	using const_array_iterator = POXY_IMPLEMENTATION_DETAIL(impl::array_iterator<true>);
-
-	class TOML_EXPORTED_CLASS array : public node
-	{
-	  private:
-
-		using vector_type			= std::vector<impl::node_ptr>;
-		using vector_iterator		= typename vector_type::iterator;
-		using const_vector_iterator = typename vector_type::const_iterator;
-		vector_type elems_;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array(const impl::array_init_elem*, const impl::array_init_elem*);
-
-		TOML_NODISCARD_CTOR
-		array(std::false_type, std::initializer_list<impl::array_init_elem> elems) //
-			: array{ elems.begin(), elems.end() }
-		{}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void preinsertion_resize(size_t idx, size_t count);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void insert_at_back(impl::node_ptr&&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		vector_iterator insert_at(const_vector_iterator, impl::node_ptr&&);
-
-		template <typename T>
-		void emplace_back_if_not_empty_view(T&& val, value_flags flags)
-		{
-			if constexpr (is_node_view<T>)
-			{
-				if (!val)
-					return;
-			}
-			insert_at_back(impl::make_node(static_cast<T&&>(val), flags));
-		}
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		size_t total_leaf_count() const noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void flatten_child(array&& child, size_t& dest_index) noexcept;
-
-	  public:
-		using value_type	  = node;
-		using size_type		  = size_t;
-		using difference_type = ptrdiff_t;
-		using reference		  = node&;
-		using const_reference = const node&;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		~array() noexcept;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array(const array&);
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array(array&& other) noexcept;
-
-		TOML_CONSTRAINED_TEMPLATE((sizeof...(ElemTypes) > 0 || !std::is_same_v<impl::remove_cvref<ElemType>, array>),
-								  typename ElemType,
-								  typename... ElemTypes)
-		TOML_NODISCARD_CTOR
-		explicit array(ElemType&& val, ElemTypes&&... vals)
-			: array{ std::false_type{},
-					 std::initializer_list<impl::array_init_elem>{ static_cast<ElemType&&>(val),
-																   static_cast<ElemTypes&&>(vals)... } }
-		{}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array& operator=(const array&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array& operator=(array&& rhs) noexcept;
-
-		TOML_CONST_INLINE_GETTER
-		node_type type() const noexcept final
-		{
-			return node_type::array;
-		}
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype) const noexcept final;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept final;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept final;
-
-		template <typename ElemType = void>
-		TOML_PURE_GETTER
-		bool is_homogeneous() const noexcept
-		{
-			using type = impl::remove_cvref<impl::unwrap_node<ElemType>>;
-			static_assert(std::is_void_v<type> || toml::is_value<type> || toml::is_container<type>,
-						  "The template type argument of array::is_homogeneous() must be void or one "
-						  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			return is_homogeneous(impl::node_type_of<type>);
-		}
-		TOML_CONST_INLINE_GETTER
-		bool is_table() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_array() const noexcept final
-		{
-			return true;
-		}
-
-		TOML_PURE_GETTER
-		bool is_array_of_tables() const noexcept final
-		{
-			return is_homogeneous(node_type::table);
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_value() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_string() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_integer() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_floating_point() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_number() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_boolean() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_time() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date_time() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		table* as_table() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		array* as_array() noexcept final
-		{
-			return this;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<std::string>* as_string() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<int64_t>* as_integer() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<double>* as_floating_point() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<bool>* as_boolean() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<date>* as_date() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<time>* as_time() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<date_time>* as_date_time() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const table* as_table() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const array* as_array() const noexcept final
-		{
-			return this;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<std::string>* as_string() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<int64_t>* as_integer() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<double>* as_floating_point() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<bool>* as_boolean() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<date>* as_date() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<time>* as_time() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<date_time>* as_date_time() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		node* get(size_t index) noexcept
-		{
-			return index < elems_.size() ? elems_[index].get() : nullptr;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const node* get(size_t index) const noexcept
-		{
-			return const_cast<array&>(*this).get(index);
-		}
-
-		template <typename ElemType>
-		TOML_NODISCARD
-		impl::wrap_node<ElemType>* get_as(size_t index) noexcept
-		{
-			if (auto val = get(index))
-				return val->template as<ElemType>();
-			return nullptr;
-		}
-
-		template <typename ElemType>
-		TOML_NODISCARD
-		const impl::wrap_node<ElemType>* get_as(size_t index) const noexcept
-		{
-			return const_cast<array&>(*this).template get_as<ElemType>(index);
-		}
-
-		using node::operator[]; // inherit operator[toml::path]
-		TOML_NODISCARD
-		node& operator[](size_t index) noexcept
-		{
-			return *elems_[index];
-		}
-
-		TOML_NODISCARD
-		const node& operator[](size_t index) const noexcept
-		{
-			return *elems_[index];
-		}
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node& at(size_t index);
-
-		TOML_NODISCARD
-		const node& at(size_t index) const
-		{
-			return const_cast<array&>(*this).at(index);
-		}
-
-		TOML_NODISCARD
-		node& front() noexcept
-		{
-			return *elems_.front();
-		}
-
-		TOML_NODISCARD
-		const node& front() const noexcept
-		{
-			return *elems_.front();
-		}
-
-		TOML_NODISCARD
-		node& back() noexcept
-		{
-			return *elems_.back();
-		}
-
-		TOML_NODISCARD
-		const node& back() const noexcept
-		{
-			return *elems_.back();
-		}
-
-		using iterator = array_iterator;
-
-		using const_iterator = const_array_iterator;
-
-		TOML_NODISCARD
-		iterator begin() noexcept
-		{
-			return iterator{ elems_.begin() };
-		}
-
-		TOML_NODISCARD
-		const_iterator begin() const noexcept
-		{
-			return const_iterator{ elems_.cbegin() };
-		}
-
-		TOML_NODISCARD
-		const_iterator cbegin() const noexcept
-		{
-			return const_iterator{ elems_.cbegin() };
-		}
-
-		TOML_NODISCARD
-		iterator end() noexcept
-		{
-			return iterator{ elems_.end() };
-		}
-
-		TOML_NODISCARD
-		const_iterator end() const noexcept
-		{
-			return const_iterator{ elems_.cend() };
-		}
-
-		TOML_NODISCARD
-		const_iterator cend() const noexcept
-		{
-			return const_iterator{ elems_.cend() };
-		}
-
-	  private:
-
-		template <typename T, typename Array>
-		using for_each_elem_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Array>;
-
-		template <typename Func, typename Array, typename T>
-		static constexpr bool can_for_each = std::is_invocable_v<Func, for_each_elem_ref<T, Array>, size_t> //
-										  || std::is_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
-										  || std::is_invocable_v<Func, for_each_elem_ref<T, Array>>;
-
-		template <typename Func, typename Array, typename T>
-		static constexpr bool can_for_each_nothrow =
-			std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>, size_t>	  //
-			|| std::is_nothrow_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
-			|| std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>>;
-
-		template <typename Func, typename Array>
-		static constexpr bool can_for_each_any = can_for_each<Func, Array, table>		//
-											  || can_for_each<Func, Array, array>		//
-											  || can_for_each<Func, Array, std::string> //
-											  || can_for_each<Func, Array, int64_t>		//
-											  || can_for_each<Func, Array, double>		//
-											  || can_for_each<Func, Array, bool>		//
-											  || can_for_each<Func, Array, date>		//
-											  || can_for_each<Func, Array, time>		//
-											  || can_for_each<Func, Array, date_time>;
-
-		template <typename Func, typename Array, typename T>
-		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Array, T> //
-													 || can_for_each_nothrow<Func, Array, T>;
-
-		// clang-format off
-
-		template <typename Func, typename Array>
-		static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Array, table>		  //
-												 && for_each_is_nothrow_one<Func, Array, array>		  //
-												 && for_each_is_nothrow_one<Func, Array, std::string> //
-												 && for_each_is_nothrow_one<Func, Array, int64_t>	  //
-												 && for_each_is_nothrow_one<Func, Array, double>	  //
-												 && for_each_is_nothrow_one<Func, Array, bool>		  //
-												 && for_each_is_nothrow_one<Func, Array, date>		  //
-												 && for_each_is_nothrow_one<Func, Array, time>		  //
-												 && for_each_is_nothrow_one<Func, Array, date_time>;
-
-		// clang-format on
-
-		template <typename Func, typename Array>
-		static void do_for_each(Func&& visitor, Array&& arr) noexcept(for_each_is_nothrow<Func&&, Array&&>)
-		{
-			static_assert(can_for_each_any<Func&&, Array&&>,
-						  "TOML array for_each visitors must be invocable for at least one of the toml::node "
-						  "specializations:" TOML_SA_NODE_TYPE_LIST);
-
-			for (size_t i = 0; i < arr.size(); i++)
-			{
-				using node_ref = impl::copy_cvref<toml::node, Array&&>;
-				static_assert(std::is_reference_v<node_ref>);
-
-				const auto keep_going =
-					static_cast<node_ref>(static_cast<Array&&>(arr)[i])
-						.visit(
-							[&](auto&& elem)
-#if !TOML_MSVC // MSVC thinks this is invalid syntax O_o
-								noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>)
-#endif
-							{
-								using elem_ref = for_each_elem_ref<decltype(elem), Array&&>;
-								static_assert(std::is_reference_v<elem_ref>);
-
-								// func(elem, i)
-								if constexpr (std::is_invocable_v<Func&&, elem_ref, size_t>)
-								{
-									using return_type =
-										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
-
-									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
-									{
-										return static_cast<bool>(
-											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
-									}
-									else
-									{
-										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
-										return true;
-									}
-								}
-
-								// func(i, elem)
-								else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
-								{
-									using return_type =
-										decltype(static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
-
-									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
-									{
-										return static_cast<bool>(
-											static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
-									}
-									else
-									{
-										static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
-										return true;
-									}
-								}
-
-								// func(elem)
-								else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
-								{
-									using return_type =
-										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
-
-									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
-									{
-										return static_cast<bool>(
-											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
-									}
-									else
-									{
-										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
-										return true;
-									}
-								}
-
-								// visitor not compatible with this particular type
-								else
-									return true;
-							});
-
-				if (!keep_going)
-					return;
-			}
-		}
-
-	  public:
-
-		template <typename Func>
-		array& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, array&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), *this);
-			return *this;
-		}
-
-		template <typename Func>
-		array&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, array&&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), static_cast<array&&>(*this));
-			return static_cast<array&&>(*this);
-		}
-
-		template <typename Func>
-		const array& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const array&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), *this);
-			return *this;
-		}
-
-		template <typename Func>
-		const array&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const array&&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), static_cast<const array&&>(*this));
-			return static_cast<const array&&>(*this);
-		}
-
-		TOML_NODISCARD
-		bool empty() const noexcept
-		{
-			return elems_.empty();
-		}
-
-		TOML_NODISCARD
-		size_t size() const noexcept
-		{
-			return elems_.size();
-		}
-
-		TOML_NODISCARD
-		size_t max_size() const noexcept
-		{
-			return elems_.max_size();
-		}
-
-		TOML_NODISCARD
-		size_t capacity() const noexcept
-		{
-			return elems_.capacity();
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void reserve(size_t new_capacity);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void shrink_to_fit();
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void truncate(size_t new_size);
-
-		template <typename ElemType>
-		void resize(size_t new_size,
-					ElemType&& default_init_val,
-					value_flags default_init_flags = preserve_source_value_flags)
-		{
-			static_assert(!is_node_view<ElemType>,
-						  "The default element type argument to toml::array::resize may not be toml::node_view.");
-
-			if (!new_size)
-				clear();
-			else if (new_size > elems_.size())
-				insert(cend(), new_size - elems_.size(), static_cast<ElemType&&>(default_init_val), default_init_flags);
-			else
-				truncate(new_size);
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		iterator erase(const_iterator pos) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		iterator erase(const_iterator first, const_iterator last) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array& flatten() &;
-
-		array&& flatten() &&
-		{
-			return static_cast<toml::array&&>(this->flatten());
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		array& prune(bool recursive = true) & noexcept;
-
-		array&& prune(bool recursive = true) && noexcept
-		{
-			return static_cast<toml::array&&>(this->prune(recursive));
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void pop_back() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void clear() noexcept;
-
-		template <typename ElemType>
-		iterator insert(const_iterator pos, ElemType&& val, value_flags flags = preserve_source_value_flags)
-		{
-			if constexpr (is_node_view<ElemType>)
-			{
-				if (!val)
-					return end();
-			}
-			return iterator{ insert_at(const_vector_iterator{ pos },
-									   impl::make_node(static_cast<ElemType&&>(val), flags)) };
-		}
-
-		template <typename ElemType>
-		iterator insert(const_iterator pos,
-						size_t count,
-						ElemType&& val,
-						value_flags flags = preserve_source_value_flags)
-		{
-			if constexpr (is_node_view<ElemType>)
-			{
-				if (!val)
-					return end();
-			}
-			switch (count)
-			{
-				case 0: return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
-				case 1: return insert(pos, static_cast<ElemType&&>(val), flags);
-				default:
-				{
-					const auto start_idx = static_cast<size_t>(const_vector_iterator{ pos } - elems_.cbegin());
-					preinsertion_resize(start_idx, count);
-					size_t i = start_idx;
-					for (size_t e = start_idx + count - 1u; i < e; i++)
-						elems_[i] = impl::make_node(val, flags);
-
-					elems_[i] = impl::make_node(static_cast<ElemType&&>(val), flags);
-					return iterator{ elems_.begin() + static_cast<ptrdiff_t>(start_idx) };
-				}
-			}
-		}
-
-		template <typename Iter>
-		iterator insert(const_iterator pos, Iter first, Iter last, value_flags flags = preserve_source_value_flags)
-		{
-			const auto distance = std::distance(first, last);
-			if (distance <= 0)
-				return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
-			else
-			{
-				auto count		 = distance;
-				using deref_type = decltype(*first);
-				if constexpr (is_node_view<deref_type>)
-				{
-					for (auto it = first; it != last; it++)
-						if (!(*it))
-							count--;
-					if (!count)
-						return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
-				}
-				const auto start_idx = static_cast<size_t>(const_vector_iterator{ pos } - elems_.cbegin());
-				preinsertion_resize(start_idx, static_cast<size_t>(count));
-				size_t i = start_idx;
-				for (auto it = first; it != last; it++)
-				{
-					if constexpr (is_node_view<deref_type>)
-					{
-						if (!(*it))
-							continue;
-					}
-					if constexpr (std::is_rvalue_reference_v<deref_type>)
-						elems_[i++] = impl::make_node(std::move(*it), flags);
-					else
-						elems_[i++] = impl::make_node(*it, flags);
-				}
-				return iterator{ elems_.begin() + static_cast<ptrdiff_t>(start_idx) };
-			}
-		}
-
-		template <typename ElemType>
-		iterator insert(const_iterator pos,
-						std::initializer_list<ElemType> ilist,
-						value_flags flags = preserve_source_value_flags)
-		{
-			return insert(pos, ilist.begin(), ilist.end(), flags);
-		}
-
-		template <typename ElemType = void, typename... Args>
-		iterator emplace(const_iterator pos, Args&&... args)
-		{
-			using raw_elem_type = impl::remove_cvref<ElemType>;
-			using elem_type		= std::conditional_t<std::is_void_v<raw_elem_type>, //
-												 impl::emplaced_type_of<Args&&...>,
-												 raw_elem_type>;
-
-			using type = impl::remove_cvref<impl::unwrap_node<elem_type>>;
-			static_assert(impl::is_native<type> || impl::is_one_of<type, table, array>,
-						  "Emplacement type parameter must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			return iterator{ insert_at(const_vector_iterator{ pos },
-									   impl::node_ptr{ new impl::wrap_node<type>{ static_cast<Args&&>(args)... } }) };
-		}
-
-		template <typename ElemType>
-		iterator replace(const_iterator pos, ElemType&& val, value_flags flags = preserve_source_value_flags)
-		{
-			TOML_ASSERT(pos >= cbegin() && pos < cend());
-
-			if constexpr (is_node_view<ElemType>)
-			{
-				if (!val)
-					return end();
-			}
-
-			const auto it = elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin());
-			*it			  = impl::make_node(static_cast<ElemType&&>(val), flags);
-			return iterator{ it };
-		}
-
-		template <typename ElemType>
-		void push_back(ElemType&& val, value_flags flags = preserve_source_value_flags)
-		{
-			emplace_back_if_not_empty_view(static_cast<ElemType&&>(val), flags);
-		}
-
-		template <typename ElemType = void, typename... Args>
-		decltype(auto) emplace_back(Args&&... args)
-		{
-			using raw_elem_type = impl::remove_cvref<ElemType>;
-			using elem_type		= std::conditional_t<std::is_void_v<raw_elem_type>, //
-												 impl::emplaced_type_of<Args&&...>,
-												 raw_elem_type>;
-
-			static constexpr auto moving_node_ptr = std::is_same_v<elem_type, impl::node_ptr> //
-												 && sizeof...(Args) == 1u					  //
-												 && impl::first_is_same<impl::node_ptr&&, Args&&...>;
-
-			using unwrapped_type = impl::remove_cvref<impl::unwrap_node<elem_type>>;
-
-			static_assert(
-				moving_node_ptr										  //
-					|| impl::is_native<unwrapped_type>				  //
-					|| impl::is_one_of<unwrapped_type, table, array>, //
-				"ElemType argument of array::emplace_back() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			if constexpr (moving_node_ptr)
-			{
-				insert_at_back(static_cast<Args&&>(args)...);
-				return *elems_.back();
-			}
-			else
-			{
-				auto ptr = new impl::wrap_node<unwrapped_type>{ static_cast<Args&&>(args)... };
-				insert_at_back(impl::node_ptr{ ptr });
-				return *ptr;
-			}
-		}
-
-	  private:
-
-		TOML_NODISCARD
-		TOML_EXPORTED_STATIC_FUNCTION
-		static bool TOML_CALLCONV equal(const array&, const array&) noexcept;
-
-		template <typename T>
-		TOML_NODISCARD
-		static bool equal_to_container(const array& lhs, const T& rhs) noexcept
-		{
-			using element_type = std::remove_const_t<typename T::value_type>;
-			static_assert(impl::is_losslessly_convertible_to_native<element_type>,
-						  "Container element type must be losslessly convertible one of the native TOML value types");
-
-			if (lhs.size() != rhs.size())
-				return false;
-			if (rhs.size() == 0u)
-				return true;
-
-			size_t i{};
-			for (auto& list_elem : rhs)
-			{
-				const auto elem = lhs.get_as<impl::native_type_of<element_type>>(i++);
-				if (!elem || *elem != list_elem)
-					return false;
-			}
-
-			return true;
-		}
-
-	  public:
-
-		TOML_NODISCARD
-		friend bool operator==(const array& lhs, const array& rhs) noexcept
-		{
-			return equal(lhs, rhs);
-		}
-
-		TOML_NODISCARD
-		friend bool operator!=(const array& lhs, const array& rhs) noexcept
-		{
-			return !equal(lhs, rhs);
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		friend bool operator==(const array& lhs, const std::initializer_list<T>& rhs) noexcept
-		{
-			return equal_to_container(lhs, rhs);
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const array&, const std::initializer_list<T>&, template <typename T>);
-
-		template <typename T>
-		TOML_NODISCARD
-		friend bool operator==(const array& lhs, const std::vector<T>& rhs) noexcept
-		{
-			return equal_to_container(lhs, rhs);
-		}
-		TOML_ASYMMETRICAL_EQUALITY_OPS(const array&, const std::vector<T>&, template <typename T>);
-
-#if TOML_ENABLE_FORMATTERS
-
-		friend std::ostream& operator<<(std::ostream& lhs, const array& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-
-#endif
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/key.h  ************************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	class key
-	{
-	  private:
-		std::string key_;
-		source_region source_;
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		key() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::string_view k, source_region&& src = {}) //
-			: key_{ k },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::string_view k, const source_region& src) //
-			: key_{ k },
-			  source_{ src }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::string&& k, source_region&& src = {}) noexcept //
-			: key_{ std::move(k) },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::string&& k, const source_region& src) noexcept //
-			: key_{ std::move(k) },
-			  source_{ src }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(const char* k, source_region&& src = {}) //
-			: key_{ k },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(const char* k, const source_region& src) //
-			: key_{ k },
-			  source_{ src }
-		{}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::wstring_view k, source_region&& src = {}) //
-			: key_{ impl::narrow(k) },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		explicit key(std::wstring_view k, const source_region& src) //
-			: key_{ impl::narrow(k) },
-			  source_{ src }
-		{}
-
-#endif
-
-		TOML_PURE_INLINE_GETTER
-		std::string_view str() const noexcept
-		{
-			return std::string_view{ key_ };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		/*implicit*/ operator std::string_view() const noexcept
-		{
-			return str();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool empty() const noexcept
-		{
-			return key_.empty();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const char* data() const noexcept
-		{
-			return key_.data();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		size_t length() const noexcept
-		{
-			return key_.length();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const source_region& source() const noexcept
-		{
-			return source_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ == rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ != rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ < rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<=(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ <= rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ > rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>=(const key& lhs, const key& rhs) noexcept
-		{
-			return lhs.key_ >= rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ == rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ != rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ < rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<=(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ <= rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ > rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>=(const key& lhs, std::string_view rhs) noexcept
-		{
-			return lhs.key_ >= rhs;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs == rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs != rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs < rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator<=(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs <= rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs > rhs.key_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator>=(std::string_view lhs, const key& rhs) noexcept
-		{
-			return lhs >= rhs.key_;
-		}
-
-		using const_iterator = const char*;
-
-		using iterator = const_iterator;
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator begin() const noexcept
-		{
-			return key_.data();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator end() const noexcept
-		{
-			return key_.data() + key_.length();
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const key& rhs)
-		{
-			impl::print_to_stream(lhs, rhs.key_);
-			return lhs;
-		}
-	};
-
-	template <typename T>
-	inline constexpr bool is_key = std::is_same_v<impl::remove_cvref<T>, toml::key>;
-
-	template <typename T>
-	inline constexpr bool is_key_or_convertible = is_key<T> //
-											   || impl::is_constructible_or_convertible<toml::key, T>;
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/std_map.h  ********************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <map>
-#include <iterator>
-TOML_ENABLE_WARNINGS;
-
-//********  impl/table.h  **********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	template <bool IsConst>
-	struct table_proxy_pair
-	{
-		using value_type = std::conditional_t<IsConst, const node, node>;
-
-		const toml::key& first;
-		value_type& second;
-	};
-
-	template <bool IsConst>
-	class table_iterator
-	{
-	  private:
-		template <bool>
-		friend class table_iterator;
-
-		using proxy_type		   = table_proxy_pair<IsConst>;
-		using mutable_map_iterator = std::map<toml::key, node_ptr, std::less<>>::iterator;
-		using const_map_iterator   = std::map<toml::key, node_ptr, std::less<>>::const_iterator;
-		using map_iterator		   = std::conditional_t<IsConst, const_map_iterator, mutable_map_iterator>;
-
-		mutable map_iterator iter_;
-		alignas(proxy_type) mutable unsigned char proxy_[sizeof(proxy_type)];
-		mutable bool proxy_instantiated_ = false;
-
-		TOML_NODISCARD
-		proxy_type* get_proxy() const noexcept
-		{
-			if (!proxy_instantiated_)
-			{
-				auto p = ::new (static_cast<void*>(proxy_)) proxy_type{ iter_->first, *iter_->second.get() };
-				proxy_instantiated_ = true;
-				return p;
-			}
-			else
-				return TOML_LAUNDER(reinterpret_cast<proxy_type*>(proxy_));
-		}
-
-	  public:
-		TOML_NODISCARD_CTOR
-		table_iterator() noexcept = default;
-
-		TOML_NODISCARD_CTOR
-		explicit table_iterator(mutable_map_iterator iter) noexcept //
-			: iter_{ iter }
-		{}
-
-		TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
-		TOML_NODISCARD_CTOR
-		explicit table_iterator(const_map_iterator iter) noexcept //
-			: iter_{ iter }
-		{}
-
-		TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
-		TOML_NODISCARD_CTOR
-		table_iterator(const table_iterator<false>& other) noexcept //
-			: iter_{ other.iter_ }
-		{}
-
-		TOML_NODISCARD_CTOR
-		table_iterator(const table_iterator& other) noexcept //
-			: iter_{ other.iter_ }
-		{}
-
-		table_iterator& operator=(const table_iterator& rhs) noexcept
-		{
-			iter_				= rhs.iter_;
-			proxy_instantiated_ = false;
-			return *this;
-		}
-
-		using value_type		= table_proxy_pair<IsConst>;
-		using reference			= value_type&;
-		using pointer			= value_type*;
-		using difference_type	= typename std::iterator_traits<map_iterator>::difference_type;
-		using iterator_category = typename std::iterator_traits<map_iterator>::iterator_category;
-
-		table_iterator& operator++() noexcept // ++pre
-		{
-			++iter_;
-			proxy_instantiated_ = false;
-			return *this;
-		}
-
-		table_iterator operator++(int) noexcept // post++
-		{
-			table_iterator out{ iter_ };
-			++iter_;
-			proxy_instantiated_ = false;
-			return out;
-		}
-
-		table_iterator& operator--() noexcept // --pre
-		{
-			--iter_;
-			proxy_instantiated_ = false;
-			return *this;
-		}
-
-		table_iterator operator--(int) noexcept // post--
-		{
-			table_iterator out{ iter_ };
-			--iter_;
-			proxy_instantiated_ = false;
-			return out;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		reference operator*() const noexcept
-		{
-			return *get_proxy();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		pointer operator->() const noexcept
-		{
-			return get_proxy();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator const map_iterator&() const noexcept
-		{
-			return iter_;
-		}
-
-		TOML_CONSTRAINED_TEMPLATE(!C, bool C = IsConst)
-		TOML_PURE_INLINE_GETTER
-		explicit operator const const_map_iterator() const noexcept
-		{
-			return iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator==(const table_iterator& lhs, const table_iterator& rhs) noexcept
-		{
-			return lhs.iter_ == rhs.iter_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		friend bool operator!=(const table_iterator& lhs, const table_iterator& rhs) noexcept
-		{
-			return lhs.iter_ != rhs.iter_;
-		}
-	};
-
-	struct table_init_pair
-	{
-		mutable toml::key key;
-		mutable node_ptr value;
-
-		template <typename K, typename V>
-		TOML_NODISCARD_CTOR
-		table_init_pair(K&& k, V&& v, value_flags flags = preserve_source_value_flags) //
-			: key{ static_cast<K&&>(k) },
-			  value{ make_node(static_cast<V&&>(v), flags) }
-		{}
-	};
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	using table_iterator = POXY_IMPLEMENTATION_DETAIL(impl::table_iterator<false>);
-
-	using const_table_iterator = POXY_IMPLEMENTATION_DETAIL(impl::table_iterator<true>);
-
-	class TOML_EXPORTED_CLASS table : public node
-	{
-	  private:
-
-		using map_type			 = std::map<toml::key, impl::node_ptr, std::less<>>;
-		using map_pair			 = std::pair<const toml::key, impl::node_ptr>;
-		using map_iterator		 = typename map_type::iterator;
-		using const_map_iterator = typename map_type::const_iterator;
-		map_type map_;
-
-		bool inline_ = false;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table(const impl::table_init_pair*, const impl::table_init_pair*);
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		~table() noexcept;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table(const table&);
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table(table&& other) noexcept;
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		explicit table(std::initializer_list<impl::table_init_pair> kvps) //
-			: table(kvps.begin(), kvps.end())
-		{}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table& operator=(const table&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table& operator=(table&& rhs) noexcept;
-
-		TOML_CONST_INLINE_GETTER
-		node_type type() const noexcept final
-		{
-			return node_type::table;
-		}
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype) const noexcept final;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept final;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept final;
-
-		template <typename ElemType = void>
-		TOML_PURE_GETTER
-		bool is_homogeneous() const noexcept
-		{
-			using type = impl::remove_cvref<impl::unwrap_node<ElemType>>;
-			static_assert(std::is_void_v<type> || toml::is_value<type> || toml::is_container<type>,
-						  "The template type argument of table::is_homogeneous() must be void or one "
-						  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-			return is_homogeneous(impl::node_type_of<type>);
-		}
-		TOML_CONST_INLINE_GETTER
-		bool is_table() const noexcept final
-		{
-			return true;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_array() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_PURE_GETTER
-		bool is_array_of_tables() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_value() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_string() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_integer() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_floating_point() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_number() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_boolean() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_time() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		bool is_date_time() const noexcept final
-		{
-			return false;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		table* as_table() noexcept final
-		{
-			return this;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		array* as_array() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<std::string>* as_string() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<int64_t>* as_integer() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<double>* as_floating_point() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<bool>* as_boolean() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<date>* as_date() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<time>* as_time() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		toml::value<date_time>* as_date_time() noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const table* as_table() const noexcept final
-		{
-			return this;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const array* as_array() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<std::string>* as_string() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<int64_t>* as_integer() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<double>* as_floating_point() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<bool>* as_boolean() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<date>* as_date() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<time>* as_time() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		const toml::value<date_time>* as_date_time() const noexcept final
-		{
-			return nullptr;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool is_inline() const noexcept
-		{
-			return inline_;
-		}
-
-		void is_inline(bool val) noexcept
-		{
-			inline_ = val;
-		}
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node* get(std::string_view key) noexcept;
-
-		TOML_PURE_INLINE_GETTER
-		const node* get(std::string_view key) const noexcept
-		{
-			return const_cast<table&>(*this).get(key);
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node* get(std::wstring_view key)
-		{
-			if (empty())
-				return nullptr;
-
-			return get(impl::narrow(key));
-		}
-
-		TOML_NODISCARD
-		const node* get(std::wstring_view key) const
-		{
-			return const_cast<table&>(*this).get(key);
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		template <typename T>
-		TOML_PURE_GETTER
-		impl::wrap_node<T>* get_as(std::string_view key) noexcept
-		{
-			const auto n = this->get(key);
-			return n ? n->template as<T>() : nullptr;
-		}
-
-		template <typename T>
-		TOML_PURE_GETTER
-		const impl::wrap_node<T>* get_as(std::string_view key) const noexcept
-		{
-			return const_cast<table&>(*this).template get_as<T>(key);
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		template <typename T>
-		TOML_NODISCARD
-		impl::wrap_node<T>* get_as(std::wstring_view key)
-		{
-			if (empty())
-				return nullptr;
-
-			return get_as<T>(impl::narrow(key));
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		const impl::wrap_node<T>* get_as(std::wstring_view key) const
-		{
-			return const_cast<table&>(*this).template get_as<T>(key);
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node& at(std::string_view key);
-
-		TOML_NODISCARD
-		const node& at(std::string_view key) const
-		{
-			return const_cast<table&>(*this).at(key);
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node& at(std::wstring_view key)
-		{
-			return at(impl::narrow(key));
-		}
-
-		TOML_NODISCARD
-		const node& at(std::wstring_view key) const
-		{
-			return const_cast<table&>(*this).at(key);
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		using iterator = toml::table_iterator;
-
-		using const_iterator = toml::const_table_iterator;
-
-		TOML_PURE_INLINE_GETTER
-		iterator begin() noexcept
-		{
-			return iterator{ map_.begin() };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator begin() const noexcept
-		{
-			return const_iterator{ map_.cbegin() };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator cbegin() const noexcept
-		{
-			return const_iterator{ map_.cbegin() };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		iterator end() noexcept
-		{
-			return iterator{ map_.end() };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator end() const noexcept
-		{
-			return const_iterator{ map_.cend() };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const_iterator cend() const noexcept
-		{
-			return const_iterator{ map_.cend() };
-		}
-
-	  private:
-
-		template <typename T, typename Table>
-		using for_each_value_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Table>;
-
-		template <typename Func, typename Table, typename T>
-		static constexpr bool can_for_each = std::is_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
-										  || std::is_invocable_v<Func, for_each_value_ref<T, Table>>;
-
-		template <typename Func, typename Table, typename T>
-		static constexpr bool can_for_each_nothrow =
-			std::is_nothrow_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
-			|| std::is_nothrow_invocable_v<Func, for_each_value_ref<T, Table>>;
-
-		template <typename Func, typename Table>
-		static constexpr bool can_for_each_any = can_for_each<Func, Table, table>		//
-											  || can_for_each<Func, Table, array>		//
-											  || can_for_each<Func, Table, std::string> //
-											  || can_for_each<Func, Table, int64_t>		//
-											  || can_for_each<Func, Table, double>		//
-											  || can_for_each<Func, Table, bool>		//
-											  || can_for_each<Func, Table, date>		//
-											  || can_for_each<Func, Table, time>		//
-											  || can_for_each<Func, Table, date_time>;
-
-		template <typename Func, typename Table, typename T>
-		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Table, T> //
-													 || can_for_each_nothrow<Func, Table, T>;
-
-		// clang-format off
-
-		  template <typename Func, typename Table>
-		  static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Table, table>		//
-												   && for_each_is_nothrow_one<Func, Table, array>		//
-												   && for_each_is_nothrow_one<Func, Table, std::string> //
-												   && for_each_is_nothrow_one<Func, Table, int64_t>		//
-												   && for_each_is_nothrow_one<Func, Table, double>		//
-												   && for_each_is_nothrow_one<Func, Table, bool>		//
-												   && for_each_is_nothrow_one<Func, Table, date>		//
-												   && for_each_is_nothrow_one<Func, Table, time>		//
-												   && for_each_is_nothrow_one<Func, Table, date_time>;
-
-		// clang-format on
-
-		template <typename Func, typename Table>
-		static void do_for_each(Func&& visitor, Table&& tbl) noexcept(for_each_is_nothrow<Func&&, Table&&>)
-		{
-			static_assert(can_for_each_any<Func&&, Table&&>,
-						  "TOML table for_each visitors must be invocable for at least one of the toml::node "
-						  "specializations:" TOML_SA_NODE_TYPE_LIST);
-
-			using kvp_type = impl::copy_cv<map_pair, std::remove_reference_t<Table>>;
-
-			for (kvp_type& kvp : tbl.map_)
-			{
-				using node_ref = impl::copy_cvref<toml::node, Table&&>;
-				static_assert(std::is_reference_v<node_ref>);
-
-				const auto keep_going =
-					static_cast<node_ref>(*kvp.second)
-						.visit(
-							[&](auto&& v)
-#if !TOML_MSVC // MSVC thinks this is invalid syntax O_o
-								noexcept(for_each_is_nothrow_one<Func&&, Table&&, decltype(v)>)
-#endif
-							{
-								using value_ref = for_each_value_ref<decltype(v), Table&&>;
-								static_assert(std::is_reference_v<value_ref>);
-
-								// func(key, val)
-								if constexpr (std::is_invocable_v<Func&&, const key&, value_ref>)
-								{
-									using return_type = decltype(static_cast<Func&&>(
-										visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
-
-									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
-									{
-										return static_cast<bool>(static_cast<Func&&>(
-											visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
-									}
-									else
-									{
-										static_cast<Func&&>(visitor)(static_cast<const key&>(kvp.first),
-																	 static_cast<value_ref>(v));
-										return true;
-									}
-								}
-
-								// func(val)
-								else if constexpr (std::is_invocable_v<Func&&, value_ref>)
-								{
-									using return_type =
-										decltype(static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
-
-									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
-									{
-										return static_cast<bool>(
-											static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
-									}
-									else
-									{
-										static_cast<Func&&>(visitor)(static_cast<value_ref>(v));
-										return true;
-									}
-								}
-
-								// visitor not compatible with this particular type
-								else
-									return true;
-							});
-
-				if (!keep_going)
-					return;
-			}
-		}
-
-	  public:
-
-		template <typename Func>
-		table& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, table&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), *this);
-			return *this;
-		}
-
-		template <typename Func>
-		table&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, table&&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), static_cast<table&&>(*this));
-			return static_cast<table&&>(*this);
-		}
-
-		template <typename Func>
-		const table& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const table&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), *this);
-			return *this;
-		}
-
-		template <typename Func>
-		const table&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const table&&>)
-		{
-			do_for_each(static_cast<Func&&>(visitor), static_cast<const table&&>(*this));
-			return static_cast<const table&&>(*this);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool empty() const noexcept
-		{
-			return map_.empty();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		size_t size() const noexcept
-		{
-			return map_.size();
-		}
-
-	  private:
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		map_iterator get_lower_bound(std::string_view) noexcept;
-
-	  public:
-
-		TOML_PURE_GETTER
-		iterator lower_bound(std::string_view key) noexcept
-		{
-			return iterator{ get_lower_bound(key) };
-		}
-
-		TOML_PURE_GETTER
-		const_iterator lower_bound(std::string_view key) const noexcept
-		{
-			return const_iterator{ const_cast<table&>(*this).get_lower_bound(key) };
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		iterator lower_bound(std::wstring_view key)
-		{
-			if (empty())
-				return end();
-
-			return lower_bound(impl::narrow(key));
-		}
-
-		TOML_NODISCARD
-		const_iterator lower_bound(std::wstring_view key) const
-		{
-			if (empty())
-				return end();
-
-			return lower_bound(impl::narrow(key));
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		iterator find(std::string_view key) noexcept;
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_MEMBER_FUNCTION
-		const_iterator find(std::string_view key) const noexcept;
-
-		TOML_PURE_GETTER
-		bool contains(std::string_view key) const noexcept
-		{
-			return get(key) != nullptr;
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		iterator find(std::wstring_view key)
-		{
-			if (empty())
-				return end();
-
-			return find(impl::narrow(key));
-		}
-
-		TOML_NODISCARD
-		const_iterator find(std::wstring_view key) const
-		{
-			return find(impl::narrow(key));
-		}
-
-		TOML_NODISCARD
-		bool contains(std::wstring_view key) const
-		{
-			return contains(impl::narrow(key));
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-	  private:
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		map_iterator erase(const_map_iterator) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		map_iterator erase(const_map_iterator, const_map_iterator) noexcept;
-
-	  public:
-
-		iterator erase(iterator pos) noexcept
-		{
-			return iterator{ erase(const_map_iterator{ pos }) };
-		}
-
-		iterator erase(const_iterator pos) noexcept
-		{
-			return iterator{ erase(const_map_iterator{ pos }) };
-		}
-
-		iterator erase(const_iterator begin, const_iterator end) noexcept
-		{
-			return iterator{ erase(const_map_iterator{ begin }, const_map_iterator{ end }) };
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		size_t erase(std::string_view key) noexcept;
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		size_t erase(std::wstring_view key)
-		{
-			if (empty())
-				return false;
-
-			return erase(impl::narrow(key));
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		table& prune(bool recursive = true) & noexcept;
-
-		table&& prune(bool recursive = true) && noexcept
-		{
-			return static_cast<toml::table&&>(this->prune(recursive));
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void clear() noexcept;
-
-	  private:
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		map_iterator insert_with_hint(const_iterator, key&&, impl::node_ptr&&);
-
-	  public:
-
-		TOML_CONSTRAINED_TEMPLATE((is_key_or_convertible<KeyType&&> || impl::is_wide_string<KeyType>),
-								  typename ValueType = void,
-								  typename KeyType,
-								  typename... ValueArgs)
-		iterator emplace_hint(const_iterator hint, KeyType&& key, ValueArgs&&... args)
-		{
-			static_assert(!impl::is_wide_string<KeyType> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Emplacement using wide-character keys is only supported on Windows with "
-						  "TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			using raw_value_type = impl::remove_cvref<ValueType>;
-			using value_type	 = std::
-				conditional_t<std::is_void_v<raw_value_type>, impl::emplaced_type_of<ValueArgs&&...>, raw_value_type>;
-
-			if constexpr (impl::is_wide_string<KeyType>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return emplace_hint<value_type>(hint,
-												impl::narrow(static_cast<KeyType&&>(key)),
-												static_cast<ValueArgs&&>(args)...);
-#else
-				static_assert(impl::dependent_false<KeyType>, "Evaluated unreachable branch!");
-#endif
-			}
-			else
-			{
-				static constexpr auto moving_node_ptr = std::is_same_v<value_type, impl::node_ptr> //
-													 && sizeof...(ValueArgs) == 1u				   //
-													 && impl::first_is_same<impl::node_ptr&&, ValueArgs&&...>;
-				using unwrapped_type = impl::remove_cvref<impl::unwrap_node<value_type>>;
-
-				static_assert(moving_node_ptr										//
-								  || impl::is_native<unwrapped_type>				//
-								  || impl::is_one_of<unwrapped_type, table, array>, //
-							  "ValueType argument of table::emplace_hint() must be one "
-							  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-				map_iterator ipos = insert_with_hint(hint, toml::key{ static_cast<KeyType&&>(key) }, nullptr);
-
-				// if second is nullptr then we successully claimed the key and inserted the empty sentinel,
-				// so now we have to construct the actual value
-				if (!ipos->second)
-				{
-					if constexpr (moving_node_ptr)
-						ipos->second = std::move(static_cast<ValueArgs&&>(args)...);
-					else
-					{
-#if TOML_COMPILER_HAS_EXCEPTIONS
-						try
-						{
-#endif
-							ipos->second.reset(
-								new impl::wrap_node<unwrapped_type>{ static_cast<ValueArgs&&>(args)... });
-#if TOML_COMPILER_HAS_EXCEPTIONS
-						}
-						catch (...)
-						{
-							erase(const_map_iterator{ ipos }); // strong exception guarantee
-							throw;
-						}
-#endif
-					}
-				}
-				return iterator{ ipos };
-			}
-		}
-
-		TOML_CONSTRAINED_TEMPLATE((is_key_or_convertible<KeyType&&> || impl::is_wide_string<KeyType>),
-								  typename KeyType,
-								  typename ValueType)
-		std::pair<iterator, bool> insert(KeyType&& key,
-										 ValueType&& val,
-										 value_flags flags = preserve_source_value_flags)
-		{
-			static_assert(!impl::is_wide_string<KeyType> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Insertion using wide-character keys is only supported on Windows with "
-						  "TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			if constexpr (is_node_view<ValueType>)
-			{
-				if (!val)
-					return { end(), false };
-			}
-
-			if constexpr (impl::is_wide_string<KeyType>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return insert(impl::narrow(static_cast<KeyType&&>(key)), static_cast<ValueType&&>(val), flags);
-#else
-				static_assert(impl::dependent_false<KeyType>, "Evaluated unreachable branch!");
-#endif
-			}
-			else
-			{
-				const auto key_view = std::string_view{ key };
-				map_iterator ipos	= get_lower_bound(key_view);
-				if (ipos == map_.end() || ipos->first != key_view)
-				{
-					ipos = insert_with_hint(const_iterator{ ipos },
-											toml::key{ static_cast<KeyType&&>(key) },
-											impl::make_node(static_cast<ValueType&&>(val), flags));
-					return { iterator{ ipos }, true };
-				}
-				return { iterator{ ipos }, false };
-			}
-		}
-
-		TOML_CONSTRAINED_TEMPLATE((!is_key_or_convertible<Iter> && !impl::is_wide_string<Iter>), typename Iter)
-		void insert(Iter begin, Iter end, value_flags flags = preserve_source_value_flags)
-		{
-			if (begin == end)
-				return;
-			for (auto it = begin; it != end; it++)
-			{
-				if constexpr (std::is_rvalue_reference_v<decltype(*it)>)
-					insert(std::move((*it).first), std::move((*it).second), flags);
-				else
-					insert((*it).first, (*it).second, flags);
-			}
-		}
-
-		TOML_CONSTRAINED_TEMPLATE((is_key_or_convertible<KeyType&&> || impl::is_wide_string<KeyType>),
-								  typename KeyType,
-								  typename ValueType)
-		std::pair<iterator, bool> insert_or_assign(KeyType&& key,
-												   ValueType&& val,
-												   value_flags flags = preserve_source_value_flags)
-		{
-			static_assert(!impl::is_wide_string<KeyType> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Insertion using wide-character keys is only supported on Windows with "
-						  "TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			if constexpr (is_node_view<ValueType>)
-			{
-				if (!val)
-					return { end(), false };
-			}
-
-			if constexpr (impl::is_wide_string<KeyType>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return insert_or_assign(impl::narrow(static_cast<KeyType&&>(key)),
-										static_cast<ValueType&&>(val),
-										flags);
-#else
-				static_assert(impl::dependent_false<KeyType>, "Evaluated unreachable branch!");
-#endif
-			}
-			else
-			{
-				const auto key_view = std::string_view{ key };
-				map_iterator ipos	= get_lower_bound(key_view);
-				if (ipos == map_.end() || ipos->first != key_view)
-				{
-					ipos = insert_with_hint(const_iterator{ ipos },
-											toml::key{ static_cast<KeyType&&>(key) },
-											impl::make_node(static_cast<ValueType&&>(val), flags));
-					return { iterator{ ipos }, true };
-				}
-				else
-				{
-					(*ipos).second = impl::make_node(static_cast<ValueType&&>(val), flags);
-					return { iterator{ ipos }, false };
-				}
-			}
-		}
-
-		TOML_CONSTRAINED_TEMPLATE((is_key_or_convertible<KeyType&&> || impl::is_wide_string<KeyType>),
-								  typename ValueType = void,
-								  typename KeyType,
-								  typename... ValueArgs)
-		std::pair<iterator, bool> emplace(KeyType&& key, ValueArgs&&... args)
-		{
-			static_assert(!impl::is_wide_string<KeyType> || TOML_ENABLE_WINDOWS_COMPAT,
-						  "Emplacement using wide-character keys is only supported on Windows with "
-						  "TOML_ENABLE_WINDOWS_COMPAT enabled.");
-
-			using raw_value_type = impl::remove_cvref<ValueType>;
-			using value_type	 = std::
-				conditional_t<std::is_void_v<raw_value_type>, impl::emplaced_type_of<ValueArgs&&...>, raw_value_type>;
-
-			if constexpr (impl::is_wide_string<KeyType>)
-			{
-#if TOML_ENABLE_WINDOWS_COMPAT
-				return emplace<value_type>(impl::narrow(static_cast<KeyType&&>(key)),
-										   static_cast<ValueArgs&&>(args)...);
-#else
-				static_assert(impl::dependent_false<KeyType>, "Evaluated unreachable branch!");
-#endif
-			}
-			else
-			{
-				using unwrapped_type = impl::remove_cvref<impl::unwrap_node<value_type>>;
-				static_assert((impl::is_native<unwrapped_type> || impl::is_one_of<unwrapped_type, table, array>),
-							  "ValueType argument of table::emplace() must be one "
-							  "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
-
-				const auto key_view = std::string_view{ key };
-				auto ipos			= get_lower_bound(key_view);
-				if (ipos == map_.end() || ipos->first != key_view)
-				{
-					ipos = insert_with_hint(
-						const_iterator{ ipos },
-						toml::key{ static_cast<KeyType&&>(key) },
-						impl::node_ptr{ new impl::wrap_node<unwrapped_type>{ static_cast<ValueArgs&&>(args)... } });
-					return { iterator{ ipos }, true };
-				}
-				return { iterator{ ipos }, false };
-			}
-		}
-
-		using node::operator[]; // inherit operator[toml::path]
-
-		TOML_NODISCARD
-		node_view<node> operator[](std::string_view key) noexcept
-		{
-			return node_view<node>{ get(key) };
-		}
-
-		TOML_NODISCARD
-		node_view<const node> operator[](std::string_view key) const noexcept
-		{
-			return node_view<const node>{ get(key) };
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node_view<node> operator[](std::wstring_view key)
-		{
-			return node_view<node>{ get(key) };
-		}
-
-		TOML_NODISCARD
-		node_view<const node> operator[](std::wstring_view key) const
-		{
-			return node_view<const node>{ get(key) };
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-	  private:
-
-		TOML_PURE_GETTER
-		TOML_EXPORTED_STATIC_FUNCTION
-		static bool TOML_CALLCONV equal(const table&, const table&) noexcept;
-
-	  public:
-
-		TOML_NODISCARD
-		friend bool operator==(const table& lhs, const table& rhs) noexcept
-		{
-			return equal(lhs, rhs);
-		}
-
-		TOML_NODISCARD
-		friend bool operator!=(const table& lhs, const table& rhs) noexcept
-		{
-			return !equal(lhs, rhs);
-		}
-
-#if TOML_ENABLE_FORMATTERS
-
-		friend std::ostream& operator<<(std::ostream& lhs, const table& rhs)
-		{
-			impl::print_to_stream(lhs, rhs);
-			return lhs;
-		}
-
-#endif
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/unicode_autogenerated.h  ******************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-#if TOML_GCC && TOML_GCC < 9
-#pragma GCC push_options
-#pragma GCC optimize("O1") // codegen bugs
-#endif
-
-// the functions in this namespace block are automatically generated by a tool - they are not meant to be hand-edited
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_CONST_GETTER
-	constexpr bool is_ascii_horizontal_whitespace(char32_t c) noexcept
-	{
-		return c == U'\t' || c == U' ';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_non_ascii_horizontal_whitespace(char32_t c) noexcept
-	{
-		// 20 code units from 8 ranges (spanning a search area of 65120)
-
-		if (c < U'\xA0' || c > U'\uFEFF')
-			return false;
-
-		const auto child_index_0 = (static_cast<uint_least64_t>(c) - 0xA0ull) / 0x3FAull;
-		if ((1ull << child_index_0) & 0x7FFFFFFFFFFFF75Eull)
-			return false;
-		if (c == U'\xA0' || c == U'\u3000' || c == U'\uFEFF')
-			return true;
-		switch (child_index_0)
-		{
-			case 0x05: return c == U'\u1680' || c == U'\u180E';
-			case 0x07:
-				return (U'\u2000' <= c && c <= U'\u200B') || (U'\u205F' <= c && c <= U'\u2060') || c == U'\u202F';
-			default: TOML_UNREACHABLE;
-		}
-
-		TOML_UNREACHABLE;
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_ascii_vertical_whitespace(char32_t c) noexcept
-	{
-		return c >= U'\n' && c <= U'\r';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_non_ascii_vertical_whitespace(char32_t c) noexcept
-	{
-		return (U'\u2028' <= c && c <= U'\u2029') || c == U'\x85';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_ascii_bare_key_character(char32_t c) noexcept
-	{
-#if TOML_LANG_UNRELEASED // toml/issues/644 ('+' in bare keys)
-		if TOML_UNLIKELY(c == U'+')
-			return true;
-#endif
-		// 64 code units from 5 ranges (spanning a search area of 78)
-
-		if (c < U'-' || c > U'z')
-			return false;
-
-		return (((static_cast<uint_least64_t>(c) - 0x2Dull) / 0x40ull) != 0ull)
-			|| ((1ull << (static_cast<uint_least64_t>(c) - 0x2Dull)) & 0xFFF43FFFFFF01FF9ull);
-	}
-
-#if TOML_LANG_UNRELEASED // toml/pull/891 (unicode bare keys)
-
-	TOML_CONST_GETTER
-	constexpr bool is_non_ascii_bare_key_character(char32_t c) noexcept
-	{
-		// 971732 code units from 16 ranges (spanning a search area of 982862)
-
-		if (c < U'\xB2' || c > U'\U000EFFFF')
-			return false;
-
-		const auto child_index_0 = (static_cast<uint_least64_t>(c) - 0xB2ull) / 0x3BFEull;
-		if ((1ull << child_index_0) & 0xFFFFFFFFFFFFFFE6ull)
-			return true;
-		switch (child_index_0)
-		{
-			case 0x00: // [0] 00B2 - 3CAF
-			{
-				// 12710 code units from 13 ranges (spanning a search area of 15358)
-
-				TOML_ASSUME(c >= U'\xB2' && c <= U'\u3CAF');
-
-				constexpr uint_least64_t bitmask_table_1[] = {
-					0xFFFFFFDFFFFFDC83u, 0xFFFFFFFFFFFFFFDFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFEFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0x000000000C003FFFu, 0xC000000000006000u, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0x000000003FFFFFFFu,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0xFFFFC00000000000u, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0x0000000000003FFFu, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u, 0x0000000000000000u,
-					0x0000000000000000u, 0xFFFFFFFFFFFFC000u, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0x3FFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFF8000u, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu,
-					0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu, 0x3FFFFFFFFFFFFFFFu,
-				};
-				return bitmask_table_1[(static_cast<uint_least64_t>(c) - 0xB2ull) / 0x40ull]
-					 & (0x1ull << ((static_cast<uint_least64_t>(c) - 0xB2ull) % 0x40ull));
-			}
-			case 0x03: return c <= U'\uD7FF';
-			case 0x04:
-				return (U'\uF900' <= c && c <= U'\uFDCF') || (U'\uFDF0' <= c && c <= U'\uFFFD') || U'\U00010000' <= c;
-			default: TOML_UNREACHABLE;
-		}
-
-		TOML_UNREACHABLE;
-	}
-
-#endif // TOML_LANG_UNRELEASED
-}
-TOML_IMPL_NAMESPACE_END;
-
-#if TOML_GCC && TOML_GCC < 9
-#pragma GCC pop_options
-#endif
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/unicode.h  ********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_CONST_GETTER
-	constexpr bool is_string_delimiter(char32_t c) noexcept
-	{
-		return c == U'"' || c == U'\'';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_ascii_letter(char32_t c) noexcept
-	{
-		return (c >= U'a' && c <= U'z') || (c >= U'A' && c <= U'Z');
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_binary_digit(char32_t c) noexcept
-	{
-		return c == U'0' || c == U'1';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_octal_digit(char32_t c) noexcept
-	{
-		return (c >= U'0' && c <= U'7');
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_decimal_digit(char32_t c) noexcept
-	{
-		return (c >= U'0' && c <= U'9');
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_hexadecimal_digit(char32_t c) noexcept
-	{
-		return U'0' <= c && c <= U'f' && (1ull << (static_cast<uint_least64_t>(c) - 0x30u)) & 0x7E0000007E03FFull;
-	}
-
-	template <typename T>
-	TOML_CONST_GETTER
-	constexpr uint_least32_t hex_to_dec(const T c) noexcept
-	{
-		if constexpr (std::is_same_v<remove_cvref<T>, uint_least32_t>)
-			return c >= 0x41u					 // >= 'A'
-					 ? 10u + (c | 0x20u) - 0x61u // - 'a'
-					 : c - 0x30u				 // - '0'
-				;
-		else
-			return hex_to_dec(static_cast<uint_least32_t>(c));
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_horizontal_whitespace(char32_t c) noexcept
-	{
-		return is_ascii_horizontal_whitespace(c) || is_non_ascii_horizontal_whitespace(c);
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_vertical_whitespace(char32_t c) noexcept
-	{
-		return is_ascii_vertical_whitespace(c) || is_non_ascii_vertical_whitespace(c);
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_whitespace(char32_t c) noexcept
-	{
-		return is_horizontal_whitespace(c) || is_vertical_whitespace(c);
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_bare_key_character(char32_t c) noexcept
-	{
-		return is_ascii_bare_key_character(c)
-#if TOML_LANG_UNRELEASED // toml/pull/891 (unicode bare keys)
-			|| is_non_ascii_bare_key_character(c)
-#endif
-			;
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_value_terminator(char32_t c) noexcept
-	{
-		return is_whitespace(c) || c == U']' || c == U'}' || c == U',' || c == U'#';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_control_character(char c) noexcept
-	{
-		return c <= '\u001F' || c == '\u007F';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_control_character(char32_t c) noexcept
-	{
-		return c <= U'\u001F' || c == U'\u007F';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_nontab_control_character(char32_t c) noexcept
-	{
-		return c <= U'\u0008' || (c >= U'\u000A' && c <= U'\u001F') || c == U'\u007F';
-	}
-
-	TOML_CONST_GETTER
-	constexpr bool is_unicode_surrogate(char32_t c) noexcept
-	{
-		return c >= 0xD800u && c <= 0xDFFF;
-	}
-
-	struct utf8_decoder
-	{
-		// utf8_decoder based on this: https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-		// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-
-		uint_least32_t state{};
-		char32_t codepoint{};
-
-		static constexpr uint8_t state_table[]{
-			0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,
-			0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,
-			0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,
-			0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,
-			0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	1,	1,	1,	1,	1,	1,	1,
-			1,	1,	1,	1,	1,	1,	1,	1,	1,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	9,	7,	7,
-			7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,	7,
-			7,	7,	7,	8,	8,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,
-			2,	2,	2,	2,	2,	2,	2,	2,	10, 3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	4,	3,	3,	11, 6,	6,
-			6,	5,	8,	8,	8,	8,	8,	8,	8,	8,	8,	8,	8,
-			0,	12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0,	12,
-			12, 12, 12, 12, 0,	12, 0,	12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12,
-			12, 24, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 36, 12,
-			36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12
-		};
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool error() const noexcept
-		{
-			return state == uint_least32_t{ 12u };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool has_code_point() const noexcept
-		{
-			return state == uint_least32_t{};
-		}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool needs_more_input() const noexcept
-		{
-			return !has_code_point() && !error();
-		}
-
-		constexpr void operator()(uint8_t byte) noexcept
-		{
-			TOML_ASSERT_ASSUME(!error());
-
-			const auto type = state_table[byte];
-
-			codepoint = static_cast<char32_t>(has_code_point() ? (uint_least32_t{ 255u } >> type) & byte
-															   : (byte & uint_least32_t{ 63u })
-																	 | (static_cast<uint_least32_t>(codepoint) << 6));
-
-			state = state_table[state + uint_least32_t{ 256u } + type];
-		}
-
-		TOML_ALWAYS_INLINE
-		constexpr void operator()(char c) noexcept
-		{
-			operator()(static_cast<uint8_t>(c));
-		}
-
-		TOML_ALWAYS_INLINE
-		constexpr void reset() noexcept
-		{
-			state = {};
-		}
-	};
-
-	TOML_PURE_GETTER
-	TOML_ATTR(nonnull)
-	bool is_ascii(const char* str, size_t len) noexcept;
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/parse_error.h  ****************************************************************************************
-
-#if TOML_ENABLE_PARSER
-
-//********  impl/std_except.h  *****************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#if TOML_EXCEPTIONS
-#include <stdexcept>
-#endif
-TOML_ENABLE_WARNINGS;
-
-//********  impl/parse_error.h  ****************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-#if TOML_DOXYGEN || !TOML_EXCEPTIONS
-#define TOML_PARSE_ERROR_BASE
-#else
-#define TOML_PARSE_ERROR_BASE	 : public std::runtime_error
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
-
-	class parse_error TOML_PARSE_ERROR_BASE
-	{
-	  private:
-#if !TOML_EXCEPTIONS
-		std::string description_;
-#endif
-		source_region source_;
-
-	  public:
-#if TOML_EXCEPTIONS
-
-		TOML_NODISCARD_CTOR
-		TOML_ATTR(nonnull)
-		parse_error(const char* desc, source_region&& src) noexcept //
-			: std::runtime_error{ desc },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		TOML_ATTR(nonnull)
-		parse_error(const char* desc, const source_region& src) noexcept //
-			: parse_error{ desc, source_region{ src } }
-		{}
-
-		TOML_NODISCARD_CTOR
-		TOML_ATTR(nonnull)
-		parse_error(const char* desc, const source_position& position, const source_path_ptr& path = {}) noexcept
-			: parse_error{ desc, source_region{ position, position, path } }
-		{}
-
-#else
-
-		TOML_NODISCARD_CTOR
-		parse_error(std::string&& desc, source_region&& src) noexcept //
-			: description_{ std::move(desc) },
-			  source_{ std::move(src) }
-		{}
-
-		TOML_NODISCARD_CTOR
-		parse_error(std::string&& desc, const source_region& src) noexcept //
-			: parse_error{ std::move(desc), source_region{ src } }
-		{}
-
-		TOML_NODISCARD_CTOR
-		parse_error(std::string&& desc, const source_position& position, const source_path_ptr& path = {}) noexcept
-			: parse_error{ std::move(desc), source_region{ position, position, path } }
-		{}
-
-#endif
-
-		TOML_NODISCARD
-		std::string_view description() const noexcept
-		{
-#if TOML_EXCEPTIONS
-			return std::string_view{ what() };
-#else
-			return description_;
-#endif
-		}
-
-		TOML_NODISCARD
-		const source_region& source() const noexcept
-		{
-			return source_;
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, const parse_error& rhs)
-		{
-			impl::print_to_stream(lhs, rhs.description());
-			impl::print_to_stream(lhs, "\n\t(error occurred at "sv);
-			impl::print_to_stream(lhs, rhs.source());
-			impl::print_to_stream(lhs, ")"sv);
-			return lhs;
-		}
-	};
-
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-}
-TOML_NAMESPACE_END;
-
-#undef TOML_PARSE_ERROR_BASE
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_PARSER
-
-//********  impl/parse_result.h  ***************************************************************************************
-
-#if TOML_DOXYGEN || (TOML_ENABLE_PARSER && !TOML_EXCEPTIONS)
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_ABI_NAMESPACE_START(noex);
-
-	class parse_result
-	{
-	  private:
-		struct storage_t
-		{
-			static constexpr size_t size =
-				(sizeof(toml::table) < sizeof(parse_error) ? sizeof(parse_error) : sizeof(toml::table));
-			static constexpr size_t align =
-				(alignof(toml::table) < alignof(parse_error) ? alignof(parse_error) : alignof(toml::table));
-
-			alignas(align) unsigned char bytes[size];
-		};
-
-		alignas(storage_t::align) mutable storage_t storage_;
-		bool err_;
-
-		template <typename Type>
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		static Type* get_as(storage_t& s) noexcept
-		{
-			return TOML_LAUNDER(reinterpret_cast<Type*>(s.bytes));
-		}
-
-		void destroy() noexcept
-		{
-			if (err_)
-				get_as<parse_error>(storage_)->~parse_error();
-			else
-				get_as<toml::table>(storage_)->~table();
-		}
-
-	  public:
-
-		TOML_NODISCARD_CTOR
-		parse_result() noexcept //
-			: err_{ true }
-		{
-			::new (static_cast<void*>(storage_.bytes)) parse_error{ std::string{}, source_region{} };
-		}
-
-		TOML_NODISCARD_CTOR
-		explicit parse_result(toml::table&& tbl) noexcept //
-			: err_{ false }
-		{
-			::new (static_cast<void*>(storage_.bytes)) toml::table{ std::move(tbl) };
-		}
-
-		TOML_NODISCARD_CTOR
-		explicit parse_result(parse_error&& err) noexcept //
-			: err_{ true }
-		{
-			::new (static_cast<void*>(storage_.bytes)) parse_error{ std::move(err) };
-		}
-
-		TOML_NODISCARD_CTOR
-		parse_result(parse_result&& res) noexcept //
-			: err_{ res.err_ }
-		{
-			if (err_)
-				::new (static_cast<void*>(storage_.bytes)) parse_error{ std::move(res).error() };
-			else
-				::new (static_cast<void*>(storage_.bytes)) toml::table{ std::move(res).table() };
-		}
-
-		parse_result& operator=(parse_result&& rhs) noexcept
-		{
-			if (err_ != rhs.err_)
-			{
-				destroy();
-				err_ = rhs.err_;
-				if (err_)
-					::new (static_cast<void*>(storage_.bytes)) parse_error{ std::move(rhs).error() };
-				else
-					::new (static_cast<void*>(storage_.bytes)) toml::table{ std::move(rhs).table() };
-			}
-			else
-			{
-				if (err_)
-					error() = std::move(rhs).error();
-				else
-					table() = std::move(rhs).table();
-			}
-			return *this;
-		}
-
-		~parse_result() noexcept
-		{
-			destroy();
-		}
-
-		TOML_NODISCARD
-		bool succeeded() const noexcept
-		{
-			return !err_;
-		}
-
-		TOML_NODISCARD
-		bool failed() const noexcept
-		{
-			return err_;
-		}
-
-		TOML_NODISCARD
-		explicit operator bool() const noexcept
-		{
-			return !err_;
-		}
-
-		TOML_NODISCARD
-		toml::table& table() & noexcept
-		{
-			TOML_ASSERT_ASSUME(!err_);
-			return *get_as<toml::table>(storage_);
-		}
-
-		TOML_NODISCARD
-		toml::table&& table() && noexcept
-		{
-			TOML_ASSERT_ASSUME(!err_);
-			return static_cast<toml::table&&>(*get_as<toml::table>(storage_));
-		}
-
-		TOML_NODISCARD
-		const toml::table& table() const& noexcept
-		{
-			TOML_ASSERT_ASSUME(!err_);
-			return *get_as<const toml::table>(storage_);
-		}
-
-		TOML_NODISCARD
-		/* implicit */ operator toml::table&() noexcept
-		{
-			return table();
-		}
-
-		TOML_NODISCARD
-		/* implicit */ operator toml::table&&() noexcept
-		{
-			return std::move(table());
-		}
-
-		TOML_NODISCARD
-		/* implicit */ operator const toml::table&() const noexcept
-		{
-			return table();
-		}
-
-		TOML_NODISCARD
-		parse_error& error() & noexcept
-		{
-			TOML_ASSERT_ASSUME(err_);
-			return *get_as<parse_error>(storage_);
-		}
-
-		TOML_NODISCARD
-		parse_error&& error() && noexcept
-		{
-			TOML_ASSERT_ASSUME(err_);
-			return static_cast<parse_error&&>(*get_as<parse_error>(storage_));
-		}
-
-		TOML_NODISCARD
-		const parse_error& error() const& noexcept
-		{
-			TOML_ASSERT_ASSUME(err_);
-			return *get_as<const parse_error>(storage_);
-		}
-
-		TOML_NODISCARD
-		explicit operator parse_error&() noexcept
-		{
-			return error();
-		}
-
-		TOML_NODISCARD
-		explicit operator parse_error&&() noexcept
-		{
-			return std::move(error());
-		}
-
-		TOML_NODISCARD
-		explicit operator const parse_error&() const noexcept
-		{
-			return error();
-		}
-
-		using iterator = table_iterator;
-
-		using const_iterator = const_table_iterator;
-
-		TOML_NODISCARD
-		table_iterator begin() noexcept
-		{
-			return err_ ? table_iterator{} : table().begin();
-		}
-
-		TOML_NODISCARD
-		const_table_iterator begin() const noexcept
-		{
-			return err_ ? const_table_iterator{} : table().begin();
-		}
-
-		TOML_NODISCARD
-		const_table_iterator cbegin() const noexcept
-		{
-			return err_ ? const_table_iterator{} : table().cbegin();
-		}
-
-		TOML_NODISCARD
-		table_iterator end() noexcept
-		{
-			return err_ ? table_iterator{} : table().end();
-		}
-
-		TOML_NODISCARD
-		const_table_iterator end() const noexcept
-		{
-			return err_ ? const_table_iterator{} : table().end();
-		}
-
-		TOML_NODISCARD
-		const_table_iterator cend() const noexcept
-		{
-			return err_ ? const_table_iterator{} : table().cend();
-		}
-
-		TOML_NODISCARD
-		node_view<node> at_path(std::string_view path) noexcept
-		{
-			return err_ ? node_view<node>{} : table().at_path(path);
-		}
-
-		TOML_NODISCARD
-		node_view<const node> at_path(std::string_view path) const noexcept
-		{
-			return err_ ? node_view<const node>{} : table().at_path(path);
-		}
-
-		TOML_NODISCARD
-		node_view<node> at_path(const toml::path& path) noexcept
-		{
-			return err_ ? node_view<node>{} : table().at_path(path);
-		}
-
-		TOML_NODISCARD
-		node_view<const node> at_path(const toml::path& path) const noexcept
-		{
-			return err_ ? node_view<const node>{} : table().at_path(path);
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node_view<node> at_path(std::wstring_view path)
-		{
-			return err_ ? node_view<node>{} : table().at_path(path);
-		}
-
-		TOML_NODISCARD
-		node_view<const node> at_path(std::wstring_view path) const
-		{
-			return err_ ? node_view<const node>{} : table().at_path(path);
-		}
-
-#endif
-
-		TOML_NODISCARD
-		node_view<node> operator[](const toml::path& path) noexcept
-		{
-			return err_ ? node_view<node>{} : table()[path];
-		}
-
-		TOML_NODISCARD
-		node_view<const node> operator[](const toml::path& path) const noexcept
-		{
-			return err_ ? node_view<const node>{} : table()[path];
-		}
-
-		TOML_NODISCARD
-		node_view<node> operator[](std::string_view key) noexcept
-		{
-			return err_ ? node_view<node>{} : table()[key];
-		}
-
-		TOML_NODISCARD
-		node_view<const node> operator[](std::string_view key) const noexcept
-		{
-			return err_ ? node_view<const node>{} : table()[key];
-		}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-		TOML_NODISCARD
-		node_view<node> operator[](std::wstring_view key)
-		{
-			return err_ ? node_view<node>{} : table()[key];
-		}
-
-		TOML_NODISCARD
-		node_view<const node> operator[](std::wstring_view key) const
-		{
-			return err_ ? node_view<const node>{} : table()[key];
-		}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-#if TOML_ENABLE_FORMATTERS
-
-		friend std::ostream& operator<<(std::ostream& os, const parse_result& result)
-		{
-			return result.err_ ? (os << result.error()) : (os << result.table());
-		}
-
-#endif
-	};
-
-	TOML_ABI_NAMESPACE_END;
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_PARSER && !TOML_EXCEPTIONS
-
-//********  impl/parser.h  *********************************************************************************************
-
-#if TOML_ENABLE_PARSER
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::string_view source_path = {});
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::string && source_path);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse_file(std::string_view file_path);
-
-#if TOML_HAS_CHAR8
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string_view source_path = {});
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string && source_path);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse_file(std::u8string_view file_path);
-
-#endif // TOML_HAS_CHAR8
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::wstring_view source_path);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::wstring_view source_path);
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse_file(std::wstring_view file_path);
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-#if TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::wstring_view source_path);
-
-#endif // TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::string_view source_path = {});
-
-	TOML_NODISCARD
-	TOML_EXPORTED_FREE_FUNCTION
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::string && source_path);
-
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-
-	inline namespace literals
-	{
-		TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, lit_ex, lit_noex);
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		parse_result operator"" _toml(const char* str, size_t len)
-		{
-			return parse(std::string_view{ str, len });
-		}
-
-#if TOML_HAS_CHAR8
-
-		TOML_NODISCARD
-		TOML_ALWAYS_INLINE
-		parse_result operator"" _toml(const char8_t* str, size_t len)
-		{
-			return parse(std::u8string_view{ str, len });
-		}
-
-#endif // TOML_HAS_CHAR8
-
-		TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_PARSER
-
-//********  impl/formatter.h  ******************************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	struct formatter_constants
-	{
-		format_flags mandatory_flags;
-		format_flags ignored_flags;
-
-		std::string_view float_pos_inf;
-		std::string_view float_neg_inf;
-		std::string_view float_nan;
-
-		std::string_view bool_true;
-		std::string_view bool_false;
-	};
-
-	struct formatter_config
-	{
-		format_flags flags;
-		std::string_view indent;
-	};
-
-	class TOML_EXPORTED_CLASS formatter
-	{
-	  private:
-		const node* source_;
-#if TOML_ENABLE_PARSER && !TOML_EXCEPTIONS
-		const parse_result* result_;
-#endif
-		const formatter_constants* constants_;
-		formatter_config config_;
-		size_t indent_columns_;
-		format_flags int_format_mask_;
-		std::ostream* stream_; //
-		int indent_;		   // these are set in attach()
-		bool naked_newline_;   //
-
-	  protected:
-		TOML_PURE_INLINE_GETTER
-		const node& source() const noexcept
-		{
-			return *source_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		std::ostream& stream() const noexcept
-		{
-			return *stream_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		int indent() const noexcept
-		{
-			return indent_;
-		}
-
-		void indent(int level) noexcept
-		{
-			indent_ = level;
-		}
-
-		void increase_indent() noexcept
-		{
-			indent_++;
-		}
-
-		void decrease_indent() noexcept
-		{
-			indent_--;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		size_t indent_columns() const noexcept
-		{
-			return indent_columns_;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool indent_array_elements() const noexcept
-		{
-			return !!(config_.flags & format_flags::indent_array_elements);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool indent_sub_tables() const noexcept
-		{
-			return !!(config_.flags & format_flags::indent_sub_tables);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool literal_strings_allowed() const noexcept
-		{
-			return !!(config_.flags & format_flags::allow_literal_strings);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool multi_line_strings_allowed() const noexcept
-		{
-			return !!(config_.flags & format_flags::allow_multi_line_strings);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool real_tabs_in_strings_allowed() const noexcept
-		{
-			return !!(config_.flags & format_flags::allow_real_tabs_in_strings);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool unicode_strings_allowed() const noexcept
-		{
-			return !!(config_.flags & format_flags::allow_unicode_strings);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool terse_kvps() const noexcept
-		{
-			return !!(config_.flags & format_flags::terse_key_value_pairs);
-		}
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void attach(std::ostream& stream) noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void detach() noexcept;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_newline(bool force = false);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_indent();
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_unformatted(char);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_unformatted(std::string_view);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_string(std::string_view str, bool allow_multi_line = true, bool allow_bare = false);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<std::string>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<int64_t>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<double>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<bool>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<date>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<time>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const value<date_time>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_value(const node&, node_type);
-
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		bool dump_failed_parse_result();
-
-		TOML_NODISCARD_CTOR
-		TOML_EXPORTED_MEMBER_FUNCTION
-		formatter(const node*, const parse_result*, const formatter_constants&, const formatter_config&) noexcept;
-	};
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/toml_formatter.h  *************************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	class TOML_EXPORTED_CLASS toml_formatter : impl::formatter
-	{
-	  private:
-
-		using base = impl::formatter;
-		std::vector<const key*> key_path_;
-		bool pending_table_separator_ = false;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_pending_table_separator();
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const key&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_inline(const toml::table&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::array&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::table&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print();
-
-		static constexpr impl::formatter_constants constants = { format_flags::none, // mandatory
-																 format_flags::none, // ignored
-																 "inf"sv,
-																 "-inf"sv,
-																 "nan"sv,
-																 "true"sv,
-																 "false"sv };
-
-	  public:
-
-		static constexpr format_flags default_flags = constants.mandatory_flags				   //
-													| format_flags::allow_literal_strings	   //
-													| format_flags::allow_multi_line_strings   //
-													| format_flags::allow_unicode_strings	   //
-													| format_flags::allow_real_tabs_in_strings //
-													| format_flags::allow_binary_integers	   //
-													| format_flags::allow_octal_integers	   //
-													| format_flags::allow_hexadecimal_integers //
-													| format_flags::indentation;
-
-		TOML_NODISCARD_CTOR
-		explicit toml_formatter(const toml::node& source, format_flags flags = default_flags) noexcept
-			: base{ &source, nullptr, constants, { flags, "    "sv } }
-		{}
-
-#if TOML_DOXYGEN || (TOML_ENABLE_PARSER && !TOML_EXCEPTIONS)
-
-		TOML_NODISCARD_CTOR
-		explicit toml_formatter(const toml::parse_result& result, format_flags flags = default_flags) noexcept
-			: base{ nullptr, &result, constants, { flags, "    "sv } }
-		{}
-
-#endif
-
-		friend std::ostream& operator<<(std::ostream& lhs, toml_formatter& rhs)
-		{
-			rhs.attach(lhs);
-			rhs.key_path_.clear();
-			rhs.print();
-			rhs.detach();
-			return lhs;
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, toml_formatter&& rhs)
-		{
-			return lhs << rhs; // as lvalue
-		}
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/json_formatter.h  *************************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	class TOML_EXPORTED_CLASS json_formatter : impl::formatter
-	{
-	  private:
-
-		using base = impl::formatter;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::table&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::array&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print();
-
-		static constexpr impl::formatter_constants constants = {
-			format_flags::quote_dates_and_times,										  // mandatory
-			format_flags::allow_literal_strings | format_flags::allow_multi_line_strings, // ignored
-			"Infinity"sv,
-			"-Infinity"sv,
-			"NaN"sv,
-			"true"sv,
-			"false"sv
-		};
-
-	  public:
-
-		static constexpr format_flags default_flags = constants.mandatory_flags				  //
-													| format_flags::quote_infinities_and_nans //
-													| format_flags::allow_unicode_strings	  //
-													| format_flags::indentation;
-
-		TOML_NODISCARD_CTOR
-		explicit json_formatter(const toml::node& source, format_flags flags = default_flags) noexcept
-			: base{ &source, nullptr, constants, { flags, "    "sv } }
-		{}
-
-#if TOML_DOXYGEN || (TOML_ENABLE_PARSER && !TOML_EXCEPTIONS)
-
-		TOML_NODISCARD_CTOR
-		explicit json_formatter(const toml::parse_result& result, format_flags flags = default_flags) noexcept
-			: base{ nullptr, &result, constants, { flags, "    "sv } }
-		{}
-
-#endif
-
-		friend std::ostream& operator<<(std::ostream& lhs, json_formatter& rhs)
-		{
-			rhs.attach(lhs);
-			rhs.print();
-			rhs.detach();
-			return lhs;
-		}
-
-		friend std::ostream& operator<<(std::ostream& lhs, json_formatter&& rhs)
-		{
-			return lhs << rhs; // as lvalue
-		}
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/yaml_formatter.h  *************************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	class TOML_EXPORTED_CLASS yaml_formatter : impl::formatter
-	{
-	  private:
-
-		using base = impl::formatter;
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print_yaml_string(const value<std::string>&);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::table&, bool = false);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print(const toml::array&, bool = false);
-
-		TOML_EXPORTED_MEMBER_FUNCTION
-		void print();
-
-		static constexpr impl::formatter_constants constants = {
-			//
-			format_flags::quote_dates_and_times | format_flags::indentation, // mandatory
-			format_flags::allow_multi_line_strings,							 // ignored
-			".inf"sv,
-			"-.inf"sv,
-			".NAN"sv,
-			"true"sv,
-			"false"sv
-		};
-
-	  public:
-
-		static constexpr format_flags default_flags = constants.mandatory_flags			  //
-													| format_flags::allow_literal_strings //
-													| format_flags::allow_unicode_strings //
-													| format_flags::allow_octal_integers  //
-													| format_flags::allow_hexadecimal_integers;
-
-		TOML_NODISCARD_CTOR
-		explicit yaml_formatter(const toml::node& source, format_flags flags = default_flags) noexcept
-			: base{ &source, nullptr, constants, { flags, "  "sv } }
-		{}
-
-#if TOML_DOXYGEN || (TOML_ENABLE_PARSER && !TOML_EXCEPTIONS)
-
-		TOML_NODISCARD_CTOR
-		explicit yaml_formatter(const toml::parse_result& result, format_flags flags = default_flags) noexcept
-			: base{ nullptr, &result, constants, { flags, "  "sv } }
-		{}
-
-#endif
-
-		friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, yaml_formatter& rhs)
-		{
-			rhs.attach(lhs);
-			rhs.print();
-			rhs.detach();
-			return lhs;
-		}
-
-		friend std::ostream& TOML_CALLCONV operator<<(std::ostream& lhs, yaml_formatter&& rhs)
-		{
-			return lhs << rhs; // as lvalue
-		}
-	};
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-#if TOML_IMPLEMENTATION
-
-//********  impl/std_string.inl  ***************************************************************************************
-
-#if TOML_WINDOWS
-
-#ifndef _WINDOWS_
-#if TOML_INCLUDE_WINDOWS_H
-#include <Windows.h>
-#else
-
-extern "C" __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int CodePage,
-																   unsigned long dwFlags,
-																   const wchar_t* lpWideCharStr,
-																   int cchWideChar,
-																   char* lpMultiByteStr,
-																   int cbMultiByte,
-																   const char* lpDefaultChar,
-																   int* lpUsedDefaultChar);
-
-extern "C" __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int CodePage,
-																   unsigned long dwFlags,
-																   const char* lpMultiByteStr,
-																   int cbMultiByte,
-																   wchar_t* lpWideCharStr,
-																   int cchWideChar);
-
-#endif // TOML_INCLUDE_WINDOWS_H
-#endif // _WINDOWS_
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	std::string narrow(std::wstring_view str)
-	{
-		if (str.empty())
-			return {};
-
-		std::string s;
-		const auto len =
-			::WideCharToMultiByte(65001, 0, str.data(), static_cast<int>(str.length()), nullptr, 0, nullptr, nullptr);
-		if (len)
-		{
-			s.resize(static_cast<size_t>(len));
-			::WideCharToMultiByte(65001,
-								  0,
-								  str.data(),
-								  static_cast<int>(str.length()),
-								  s.data(),
-								  len,
-								  nullptr,
-								  nullptr);
-		}
-		return s;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	std::wstring widen(std::string_view str)
-	{
-		if (str.empty())
-			return {};
-
-		std::wstring s;
-		const auto len = ::MultiByteToWideChar(65001, 0, str.data(), static_cast<int>(str.length()), nullptr, 0);
-		if (len)
-		{
-			s.resize(static_cast<size_t>(len));
-			::MultiByteToWideChar(65001, 0, str.data(), static_cast<int>(str.length()), s.data(), len);
-		}
-		return s;
-	}
-
-#if TOML_HAS_CHAR8
-
-	TOML_EXTERNAL_LINKAGE
-	std::wstring widen(std::u8string_view str)
-	{
-		if (str.empty())
-			return {};
-
-		return widen(std::string_view{ reinterpret_cast<const char*>(str.data()), str.length() });
-	}
-
-#endif // TOML_HAS_CHAR8
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_WINDOWS
-
-//********  impl/print_to_stream.inl  **********************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#include <ostream>
-#if TOML_INT_CHARCONV || TOML_FLOAT_CHARCONV
-#include <charconv>
-#endif
-#if !TOML_INT_CHARCONV || !TOML_FLOAT_CHARCONV
-#include <sstream>
-#endif
-#if !TOML_INT_CHARCONV
-#include <iomanip>
-#endif
-TOML_ENABLE_WARNINGS;
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_ANON_NAMESPACE_START
-{
-	template <typename T>
-	inline constexpr size_t charconv_buffer_length = 0;
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<int8_t> = 4; // strlen("-128")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<int16_t> = 6; // strlen("-32768")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<int32_t> = 11; // strlen("-2147483648")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<int64_t> = 20; // strlen("-9223372036854775808")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<uint8_t> = 3; // strlen("255")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<uint16_t> = 5; // strlen("65535")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<uint32_t> = 10; // strlen("4294967295")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<uint64_t> = 20; // strlen("18446744073709551615")
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<float> = 64;
-
-	template <>
-	inline constexpr size_t charconv_buffer_length<double> = 64;
-
-	template <typename T>
-	TOML_INTERNAL_LINKAGE
-	void print_integer_to_stream(std::ostream & stream, T val, value_flags format = {}, size_t min_digits = 0)
-	{
-		if (!val)
-		{
-			if (!min_digits)
-				min_digits = 1;
-
-			for (size_t i = 0; i < min_digits; i++)
-				stream.put('0');
-
-			return;
-		}
-
-		static constexpr auto value_flags_mask =
-			value_flags::format_as_binary | value_flags::format_as_octal | value_flags::format_as_hexadecimal;
-		format &= value_flags_mask;
-
-		int base = 10;
-		if (format != value_flags::none && val > T{})
-		{
-			switch (format)
-			{
-				case value_flags::format_as_binary: base = 2; break;
-				case value_flags::format_as_octal: base = 8; break;
-				case value_flags::format_as_hexadecimal: base = 16; break;
-				default: break;
-			}
-		}
-
-#if TOML_INT_CHARCONV
-
-		char buf[(sizeof(T) * CHAR_BIT)];
-		const auto res = std::to_chars(buf, buf + sizeof(buf), val, base);
-		const auto len = static_cast<size_t>(res.ptr - buf);
-		for (size_t i = len; i < min_digits; i++)
-			stream.put('0');
-		if (base == 16)
-		{
-			for (size_t i = 0; i < len; i++)
-				if (buf[i] >= 'a')
-					buf[i] -= 32;
-		}
-		impl::print_to_stream(stream, buf, len);
-
-#else
-
-		using unsigned_type = std::conditional_t<(sizeof(T) > sizeof(unsigned)), std::make_unsigned_t<T>, unsigned>;
-		using cast_type		= std::conditional_t<std::is_signed_v<T>, std::make_signed_t<unsigned_type>, unsigned_type>;
-
-		if (base == 2)
-		{
-			const auto len = sizeof(T) * CHAR_BIT;
-			for (size_t i = len; i < min_digits; i++)
-				stream.put('0');
-
-			bool found_one	   = false;
-			const auto v	   = static_cast<unsigned_type>(val);
-			unsigned_type mask = unsigned_type{ 1 } << (len - 1u);
-			for (size_t i = 0; i < len; i++)
-			{
-				if ((v & mask))
-				{
-					stream.put('1');
-					found_one = true;
-				}
-				else if (found_one)
-					stream.put('0');
-				mask >>= 1;
-			}
-		}
-		else
-		{
-			std::ostringstream ss;
-			ss.imbue(std::locale::classic());
-			ss << std::uppercase << std::setbase(base);
-			if (min_digits)
-				ss << std::setfill('0') << std::setw(static_cast<int>(min_digits));
-			ss << static_cast<cast_type>(val);
-			const auto str = std::move(ss).str();
-			impl::print_to_stream(stream, str);
-		}
-
-#endif
-	}
-
-	template <typename T>
-	TOML_INTERNAL_LINKAGE
-	void print_floating_point_to_stream(std::ostream & stream,
-										T val,
-										value_flags format,
-										[[maybe_unused]] bool relaxed_precision)
-	{
-		switch (impl::fpclassify(val))
-		{
-			case impl::fp_class::neg_inf: impl::print_to_stream(stream, "-inf"sv); break;
-
-			case impl::fp_class::pos_inf: impl::print_to_stream(stream, "inf"sv); break;
-
-			case impl::fp_class::nan: impl::print_to_stream(stream, "nan"sv); break;
-
-			case impl::fp_class::ok:
-			{
-				static constexpr auto needs_decimal_point = [](auto&& s) noexcept
-				{
-					for (auto c : s)
-						if (c == '.' || c == 'E' || c == 'e')
-							return false;
-					return true;
-				};
-
-#if TOML_FLOAT_CHARCONV
-
-				const auto hex = !!(format & value_flags::format_as_hexadecimal);
-				char buf[charconv_buffer_length<T>];
-				auto res = hex ? std::to_chars(buf, buf + sizeof(buf), val, std::chars_format::hex)
-							   : std::to_chars(buf, buf + sizeof(buf), val);
-				auto str = std::string_view{ buf, static_cast<size_t>(res.ptr - buf) };
-
-				char buf2[charconv_buffer_length<T>];
-				if (!hex && relaxed_precision)
-				{
-					res				= std::to_chars(buf2, buf2 + sizeof(buf2), val, std::chars_format::general, 6);
-					const auto str2 = std::string_view{ buf2, static_cast<size_t>(res.ptr - buf2) };
-					if (str2.length() < str.length())
-						str = str2;
-				}
-
-				impl::print_to_stream(stream, str);
-				if (!hex && needs_decimal_point(str))
-					toml::impl::print_to_stream(stream, ".0"sv);
-
-#else
-
-				std::ostringstream ss;
-				ss.imbue(std::locale::classic());
-				if (!relaxed_precision)
-					ss.precision(std::numeric_limits<T>::max_digits10);
-				if (!!(format & value_flags::format_as_hexadecimal))
-					ss << std::hexfloat;
-				ss << val;
-				const auto str = std::move(ss).str();
-				impl::print_to_stream(stream, str);
-				if (!(format & value_flags::format_as_hexadecimal) && needs_decimal_point(str))
-					impl::print_to_stream(stream, ".0"sv);
-
-#endif
-			}
-			break;
-
-			default: TOML_UNREACHABLE;
-		}
-	}
-}
-TOML_ANON_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	TOML_ATTR(nonnull)
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const char* val, size_t len)
-	{
-		stream.write(val, static_cast<std::streamsize>(len));
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, std::string_view val)
-	{
-		stream.write(val.data(), static_cast<std::streamsize>(val.length()));
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const std::string& val)
-	{
-		stream.write(val.data(), static_cast<std::streamsize>(val.length()));
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, char val)
-	{
-		stream.put(val);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, signed char val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, signed short val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, signed int val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, signed long val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream,
-									   signed long long val,
-									   value_flags format,
-									   size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, unsigned char val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, unsigned short val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, unsigned int val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, unsigned long val, value_flags format, size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream,
-									   unsigned long long val,
-									   value_flags format,
-									   size_t min_digits)
-	{
-		TOML_ANON_NAMESPACE::print_integer_to_stream(stream, val, format, min_digits);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, float val, value_flags format, bool relaxed_precision)
-	{
-		TOML_ANON_NAMESPACE::print_floating_point_to_stream(stream, val, format, relaxed_precision);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, double val, value_flags format, bool relaxed_precision)
-	{
-		TOML_ANON_NAMESPACE::print_floating_point_to_stream(stream, val, format, relaxed_precision);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, bool val)
-	{
-		print_to_stream(stream, val ? "true"sv : "false"sv);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::date& val)
-	{
-		print_to_stream(stream, val.year, {}, 4);
-		stream.put('-');
-		print_to_stream(stream, val.month, {}, 2);
-		stream.put('-');
-		print_to_stream(stream, val.day, {}, 2);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::time& val)
-	{
-		print_to_stream(stream, val.hour, {}, 2);
-		stream.put(':');
-		print_to_stream(stream, val.minute, {}, 2);
-		stream.put(':');
-		print_to_stream(stream, val.second, {}, 2);
-		if (val.nanosecond && val.nanosecond <= 999999999u)
-		{
-			stream.put('.');
-			auto ns		  = val.nanosecond;
-			size_t digits = 9u;
-			while (ns % 10u == 0u)
-			{
-				ns /= 10u;
-				digits--;
-			}
-			print_to_stream(stream, ns, {}, digits);
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::time_offset& val)
-	{
-		if (!val.minutes)
-		{
-			stream.put('Z');
-			return;
-		}
-
-		auto mins = static_cast<int>(val.minutes);
-		if (mins < 0)
-		{
-			stream.put('-');
-			mins = -mins;
-		}
-		else
-			stream.put('+');
-		const auto hours = mins / 60;
-		if (hours)
-		{
-			print_to_stream(stream, static_cast<unsigned int>(hours), {}, 2);
-			mins -= hours * 60;
-		}
-		else
-			print_to_stream(stream, "00"sv);
-		stream.put(':');
-		print_to_stream(stream, static_cast<unsigned int>(mins), {}, 2);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const toml::date_time& val)
-	{
-		print_to_stream(stream, val.date);
-		stream.put('T');
-		print_to_stream(stream, val.time);
-		if (val.offset)
-			print_to_stream(stream, *val.offset);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const source_position& val)
-	{
-		print_to_stream(stream, "line "sv);
-		print_to_stream(stream, val.line);
-		print_to_stream(stream, ", column "sv);
-		print_to_stream(stream, val.column);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const source_region& val)
-	{
-		print_to_stream(stream, val.begin);
-		if (val.path)
-		{
-			print_to_stream(stream, " of '"sv);
-			print_to_stream(stream, *val.path);
-			stream.put('\'');
-		}
-	}
-
-#if TOML_ENABLE_FORMATTERS
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const array& arr)
-	{
-		stream << toml_formatter{ arr };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const table& tbl)
-	{
-		stream << toml_formatter{ tbl };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<std::string>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<int64_t>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<double>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<bool>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<date>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<time>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void TOML_CALLCONV print_to_stream(std::ostream & stream, const value<date_time>& val)
-	{
-		stream << toml_formatter{ val };
-	}
-
-#endif
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/node.inl  *********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	node::node() noexcept = default;
-
-	TOML_EXTERNAL_LINKAGE
-	node::~node() noexcept = default;
-
-	TOML_EXTERNAL_LINKAGE
-	node::node(node && other) noexcept //
-		: source_{ std::exchange(other.source_, {}) }
-	{}
-
-	TOML_EXTERNAL_LINKAGE
-	node::node(const node& /*other*/) noexcept
-	{
-		// does not copy source information - this is not an error
-		//
-		// see https://github.com/marzer/tomlplusplus/issues/49#issuecomment-665089577
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node& node::operator=(const node& /*rhs*/) noexcept
-	{
-		// does not copy source information - this is not an error
-		//
-		// see https://github.com/marzer/tomlplusplus/issues/49#issuecomment-665089577
-
-		source_ = {};
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node& node::operator=(node&& rhs) noexcept
-	{
-		if (&rhs != this)
-			source_ = std::exchange(rhs.source_, {});
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> node::at_path(std::string_view path) noexcept
-	{
-		return toml::at_path(*this, path);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> node::at_path(std::string_view path) const noexcept
-	{
-		return toml::at_path(*this, path);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> node::at_path(const path& p) noexcept
-	{
-		return toml::at_path(*this, p);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> node::at_path(const path& p) const noexcept
-	{
-		return toml::at_path(*this, p);
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> node::at_path(std::wstring_view path)
-	{
-		return toml::at_path(*this, path);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> node::at_path(std::wstring_view path) const
-	{
-		return toml::at_path(*this, path);
-	}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> node::operator[](const path& p) noexcept
-	{
-		return toml::at_path(*this, p);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> node::operator[](const path& p) const noexcept
-	{
-		return toml::at_path(*this, p);
-	}
-}
-TOML_NAMESPACE_END;
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV node_deep_equality(const node* lhs, const node* rhs) noexcept
-	{
-		// both same or both null
-		if (lhs == rhs)
-			return true;
-
-		// lhs null != rhs null or different types
-		if ((!lhs != !rhs) || lhs->type() != rhs->type())
-			return false;
-
-		return lhs->visit(
-			[=](auto& l) noexcept
-			{
-				using concrete_type = remove_cvref<decltype(l)>;
-
-				return l == *(rhs->as<concrete_type>());
-			});
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/at_path.inl  ******************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#if TOML_INT_CHARCONV
-#include <charconv>
-#else
-#include <sstream>
-#endif
-TOML_ENABLE_WARNINGS;
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV parse_path(const std::string_view path,
-								  void* const data,
-								  const parse_path_callback<std::string_view> on_key,
-								  const parse_path_callback<size_t> on_index)
-	{
-		// a blank string is a valid path; it's just one component representing the "" key
-		if (path.empty())
-			return on_key(data, ""sv);
-
-		size_t pos					= 0;
-		const auto end				= path.length();
-		bool prev_was_array_indexer = false;
-		bool prev_was_dot			= true; // invisible root 'dot'
-
-		while (pos < end)
-		{
-			// start of an array indexer
-			if (path[pos] == '[')
-			{
-				// find first digit in index
-				size_t index_start = pos + 1u;
-				while (true)
-				{
-					if TOML_UNLIKELY(index_start >= path.length())
-						return false;
-
-					const auto c = path[index_start];
-					if TOML_LIKELY(c >= '0' && c <= '9')
-						break;
-					else if (c == ' ' || c == '\t')
-						index_start++;
-					else
-						return false;
-				}
-				TOML_ASSERT(path[index_start] >= '0');
-				TOML_ASSERT(path[index_start] <= '9');
-
-				// find end of index (first non-digit character)
-				size_t index_end = index_start + 1u;
-				while (true)
-				{
-					// if an array indexer is missing the trailing ']' at the end of the string, permissively accept it
-					if TOML_UNLIKELY(index_end >= path.length())
-						break;
-
-					const auto c = path[index_end];
-					if (c >= '0' && c <= '9')
-						index_end++;
-					else if (c == ']' || c == ' ' || c == '\t' || c == '.' || c == '[')
-						break;
-					else
-						return false;
-				}
-				TOML_ASSERT(path[index_end - 1u] >= '0');
-				TOML_ASSERT(path[index_end - 1u] <= '9');
-
-				// move pos to after indexer (char after closing ']' or permissively EOL/subkey '.'/next opening '[')
-				pos = index_end;
-				while (true)
-				{
-					if TOML_UNLIKELY(pos >= path.length())
-						break;
-
-					const auto c = path[pos];
-					if (c == ']')
-					{
-						pos++;
-						break;
-					}
-					else if TOML_UNLIKELY(c == '.' || c == '[')
-						break;
-					else if (c == '\t' || c == ' ')
-						pos++;
-					else
-						return false;
-				}
-
-				// get array index substring
-				auto index_str = path.substr(index_start, index_end - index_start);
-
-				// parse the actual array index to an integer type
-				size_t index;
-				if (index_str.length() == 1u)
-					index = static_cast<size_t>(index_str[0] - '0');
-				else
-				{
-#if TOML_INT_CHARCONV
-
-					auto fc_result = std::from_chars(index_str.data(), index_str.data() + index_str.length(), index);
-					if (fc_result.ec != std::errc{})
-						return false;
-
-#else
-
-					std::stringstream ss;
-					ss.imbue(std::locale::classic());
-					ss.write(index_str.data(), static_cast<std::streamsize>(index_str.length()));
-					if (!(ss >> index))
-						return false;
-
-#endif
-				}
-
-				prev_was_dot		   = false;
-				prev_was_array_indexer = true;
-
-				if (!on_index(data, index))
-					return false;
-			}
-
-			// start of a new table child
-			else if (path[pos] == '.')
-			{
-				// a dot immediately following another dot (or at the beginning of the string) is as if we'd asked
-				// for an empty child in between, e.g.
-				//
-				//     foo..bar
-				//
-				// is equivalent to
-				//
-				//     "foo".""."bar"
-				//
-				if (prev_was_dot && !on_key(data, ""sv))
-					return false;
-
-				pos++;
-				prev_was_dot		   = true;
-				prev_was_array_indexer = false;
-			}
-
-			// an errant closing ']'
-			else if TOML_UNLIKELY(path[pos] == ']')
-				return false;
-
-			// some regular subkey
-			else
-			{
-				const auto subkey_start = pos;
-				const auto subkey_len =
-					impl::min(path.find_first_of(".[]"sv, subkey_start + 1u), path.length()) - subkey_start;
-				const auto subkey = path.substr(subkey_start, subkey_len);
-
-				// a regular subkey segment immediately after an array indexer is OK if it was all whitespace, e.g.:
-				//
-				//     "foo[0]  .bar"
-				//            ^^ skip this
-				//
-				// otherwise its an error (since it would have to be preceeded by a dot)
-				if (prev_was_array_indexer)
-				{
-					auto non_ws = subkey.find_first_not_of(" \t");
-					if (non_ws == std::string_view::npos)
-					{
-						pos += subkey_len;
-						prev_was_dot		   = false;
-						prev_was_array_indexer = false;
-						continue;
-					}
-					else
-						return false;
-				}
-
-				pos += subkey_len;
-				prev_was_dot		   = false;
-				prev_was_array_indexer = false;
-
-				if (!on_key(data, subkey))
-					return false;
-			}
-		}
-
-		// Last character was a '.', which implies an empty string key at the end of the path
-		if (prev_was_dot && !on_key(data, ""sv))
-			return false;
-
-		return true;
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> TOML_CALLCONV at_path(node & root, std::string_view path) noexcept
-	{
-		// early-exit sanity-checks
-		if (root.is_value())
-			return {};
-		if (auto tbl = root.as_table(); tbl && tbl->empty())
-			return {};
-		if (auto arr = root.as_array(); arr && arr->empty())
-			return {};
-
-		node* current = &root;
-
-		static constexpr auto on_key = [](void* data, std::string_view key) noexcept -> bool
-		{
-			auto& curr = *static_cast<node**>(data);
-			TOML_ASSERT_ASSUME(curr);
-
-			const auto current_table = curr->as<table>();
-			if (!current_table)
-				return false;
-
-			curr = current_table->get(key);
-			return curr != nullptr;
-		};
-
-		static constexpr auto on_index = [](void* data, size_t index) noexcept -> bool
-		{
-			auto& curr = *static_cast<node**>(data);
-			TOML_ASSERT_ASSUME(curr);
-
-			const auto current_array = curr->as<array>();
-			if (!current_array)
-				return false;
-
-			curr = current_array->get(index);
-			return curr != nullptr;
-		};
-
-		if (!impl::parse_path(path, &current, on_key, on_index))
-			current = nullptr;
-
-		return node_view{ current };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> TOML_CALLCONV at_path(const node& root, std::string_view path) noexcept
-	{
-		return node_view<const node>{ at_path(const_cast<node&>(root), path).node() };
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> TOML_CALLCONV at_path(node & root, std::wstring_view path)
-	{
-		// these are the same top-level checks from the narrow-string version;
-		// they're hoisted up here to avoid doing the wide -> narrow conversion where it would not be necessary
-		// (avoids an allocation)
-		if (root.is_value())
-			return {};
-		if (auto tbl = root.as_table(); tbl && tbl->empty())
-			return {};
-		if (auto arr = root.as_array(); arr && arr->empty())
-			return {};
-
-		return at_path(root, impl::narrow(path));
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> TOML_CALLCONV at_path(const node& root, std::wstring_view path)
-	{
-		return node_view<const node>{ at_path(const_cast<node&>(root), path).node() };
-	}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/path.inl  *********************************************************************************************
-
-TOML_DISABLE_WARNINGS;
-#if TOML_INT_CHARCONV
-#include <charconv>
-#endif
-#include <sstream>
-TOML_ENABLE_WARNINGS;
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component() //
-		: type_{ path_component_type::key }
-	{
-		store_key("", value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(size_t index) noexcept //
-		: type_(path_component_type::array_index)
-	{
-		store_index(index, value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(std::string_view key) //
-		: type_(path_component_type::key)
-	{
-		store_key(key, value_storage_);
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(std::wstring_view key) //
-		: path_component(impl::narrow(key))
-	{}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(const path_component& pc) //
-		: type_{ pc.type_ }
-	{
-		if (type_ == path_component_type::array_index)
-			store_index(pc.index(), value_storage_);
-		else
-			store_key(pc.key(), value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component::path_component(path_component && pc) noexcept //
-		: type_{ pc.type_ }
-	{
-		if (type_ == path_component_type::array_index)
-			store_index(pc.index_ref(), value_storage_);
-		else
-			store_key(std::move(pc.key_ref()), value_storage_);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(const path_component& rhs)
-	{
-		if (type_ != rhs.type_)
-		{
-			destroy();
-
-			type_ = rhs.type_;
-			if (type_ == path_component_type::array_index)
-				store_index(rhs.index(), value_storage_);
-			else
-				store_key(rhs.key(), value_storage_);
-		}
-		else
-		{
-			if (type_ == path_component_type::array_index)
-				index_ref() = rhs.index();
-			else
-				key_ref() = rhs.key();
-		}
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(path_component&& rhs) noexcept
-	{
-		if (type_ != rhs.type_)
-		{
-			destroy();
-
-			type_ = rhs.type_;
-			if (type_ == path_component_type::array_index)
-				store_index(rhs.index(), value_storage_);
-			else
-				store_key(std::move(rhs.key_ref()), value_storage_);
-		}
-		else
-		{
-			if (type_ == path_component_type::array_index)
-				index_ref() = rhs.index();
-			else
-				key_ref() = std::move(rhs.key_ref());
-		}
-		return *this;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV path_component::equal(const path_component& lhs, const path_component& rhs) noexcept
-	{
-		// Different comparison depending on contents
-		if (lhs.type_ != rhs.type_)
-			return false;
-
-		if (lhs.type_ == path_component_type::array_index)
-			return lhs.index() == rhs.index();
-		else // path_component_type::key
-			return lhs.key() == rhs.key();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(size_t new_index) noexcept
-	{
-		// If currently a key, string will need to be destroyed regardless
-		destroy();
-
-		type_ = path_component_type::array_index;
-		store_index(new_index, value_storage_);
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(std::string_view new_key)
-	{
-		if (type_ == path_component_type::key)
-			key_ref() = new_key;
-		else
-		{
-			type_ = path_component_type::key;
-			store_key(new_key, value_storage_);
-		}
-
-		return *this;
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path_component& path_component::operator=(std::wstring_view new_key)
-	{
-		if (type_ == path_component_type::key)
-			key_ref() = impl::narrow(new_key);
-		else
-		{
-			type_ = path_component_type::key;
-			store_key(impl::narrow(new_key), value_storage_);
-		}
-
-		return *this;
-	}
-
-#endif
-}
-TOML_NAMESPACE_END;
-
-TOML_ANON_NAMESPACE_START
-{
-	TOML_INTERNAL_LINKAGE
-	bool parse_path_into(std::string_view path_str, std::vector<path_component> & components)
-	{
-		using components_type = std::remove_reference_t<decltype(components)>;
-
-		const auto original_size = components.size();
-
-		static constexpr auto on_key = [](void* data, std::string_view key) -> bool
-		{
-			auto& comps = *static_cast<components_type*>(data);
-			comps.emplace_back(key);
-			return true;
-		};
-
-		static constexpr auto on_index = [](void* data, size_t index) -> bool
-		{
-			auto& comps = *static_cast<components_type*>(data);
-			comps.emplace_back(index);
-			return true;
-		};
-
-		if (!impl::parse_path(path_str, &components, on_key, on_index))
-		{
-			components.resize(original_size);
-			return false;
-		}
-
-		return true;
-	}
-}
-TOML_ANON_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	void path::print_to(std::ostream & os) const
-	{
-		bool root = true;
-		for (const auto& component : components_)
-		{
-			if (component.type() == path_component_type::key) // key
-			{
-				if (!root)
-					impl::print_to_stream(os, '.');
-				impl::print_to_stream(os, component.key());
-			}
-			else if (component.type() == path_component_type::array_index) // array
-			{
-				impl::print_to_stream(os, '[');
-				impl::print_to_stream(os, component.index());
-				impl::print_to_stream(os, ']');
-			}
-			root = false;
-		}
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV path::equal(const path& lhs, const path& rhs) noexcept
-	{
-		return lhs.components_ == rhs.components_;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path::path(std::string_view str) //
-	{
-		TOML_ANON_NAMESPACE::parse_path_into(str, components_);
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path::path(std::wstring_view str) //
-		: path(impl::narrow(str))
-	{}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator=(std::string_view rhs)
-	{
-		components_.clear();
-		TOML_ANON_NAMESPACE::parse_path_into(rhs, components_);
-		return *this;
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator=(std::wstring_view rhs)
-	{
-		return assign(impl::narrow(rhs));
-	}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(const path& rhs)
-	{
-		components_.insert(components_.cend(), rhs.begin(), rhs.end());
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(path&& rhs)
-	{
-		components_.insert(components_.end(),
-						   std::make_move_iterator(rhs.components_.begin()),
-						   std::make_move_iterator(rhs.components_.end()));
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(std::string_view str)
-	{
-		TOML_ANON_NAMESPACE::parse_path_into(str, components_);
-		return *this;
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::operator+=(std::wstring_view str)
-	{
-		return *this += impl::narrow(str);
-	}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(const path& source)
-	{
-		components_.insert(components_.begin(), source.components_.begin(), source.components_.end());
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(path && source)
-	{
-		components_.insert(components_.begin(),
-						   std::make_move_iterator(source.components_.begin()),
-						   std::make_move_iterator(source.components_.end()));
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(std::string_view source)
-	{
-		return prepend(path{ source });
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::prepend(std::wstring_view source)
-	{
-		return prepend(impl::narrow(source));
-	}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	std::string path::str() const
-	{
-		if (empty())
-			return "";
-
-		std::ostringstream ss;
-		print_to(ss);
-		return std::move(ss).str();
-	}
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	std::wstring path::wide_str() const
-	{
-		return impl::widen(str());
-	}
-
-#endif
-
-	TOML_EXTERNAL_LINKAGE
-	void path::clear() noexcept
-	{
-		components_.clear();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path& path::truncate(size_t n)
-	{
-		n = n > components_.size() ? components_.size() : n;
-
-		auto it_end = components_.end();
-		components_.erase(it_end - static_cast<int>(n), it_end);
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::truncated(size_t n) const
-	{
-		path truncated_path{};
-
-		n = n > components_.size() ? components_.size() : n;
-
-		// Copy all components except one
-		// Need at least two path components to have a parent, since if there is
-		// only one path component, the parent is the root/null path ""
-		truncated_path.components_.insert(truncated_path.components_.begin(),
-										  components_.begin(),
-										  components_.end() - static_cast<int>(n));
-
-		return truncated_path;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::parent() const
-	{
-		return truncated(1);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::leaf(size_t n) const
-	{
-		path leaf_path{};
-
-		n = n > components_.size() ? components_.size() : n;
-
-		if (n > 0)
-		{
-			leaf_path.components_.insert(leaf_path.components_.begin(),
-										 components_.end() - static_cast<int>(n),
-										 components_.end());
-		}
-
-		return leaf_path;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::subpath(std::vector<path_component>::const_iterator start,
-					   std::vector<path_component>::const_iterator end) const
-	{
-		if (start >= end)
-			return {};
-
-		path subpath;
-		subpath.components_.insert(subpath.components_.begin(), start, end);
-		return subpath;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	path path::subpath(size_t start, size_t length) const
-	{
-		return subpath(begin() + static_cast<int>(start), begin() + static_cast<int>(start + length));
-	}
-}
-TOML_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept
-	{
-		// early-exit sanity-checks
-		if (root.is_value())
-			return {};
-		if (auto tbl = root.as_table(); tbl && tbl->empty())
-			return {};
-		if (auto arr = root.as_array(); arr && arr->empty())
-			return {};
-
-		node* current = &root;
-
-		for (const auto& component : path)
-		{
-			auto type = component.type();
-			if (type == path_component_type::array_index)
-			{
-				const auto current_array = current->as<array>();
-				if (!current_array)
-					return {}; // not an array, using array index doesn't work
-
-				current = current_array->get(component.index());
-			}
-			else if (type == path_component_type::key)
-			{
-				const auto current_table = current->as<table>();
-				if (!current_table)
-					return {};
-
-				current = current_table->get(component.key());
-			}
-			else
-			{
-				// Error: invalid component
-				return {};
-			}
-
-			if (!current)
-				return {}; // not found
-		}
-
-		return node_view{ current };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept
-	{
-		return node_view<const node>{ at_path(const_cast<node&>(root), path).node() };
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/array.inl  ********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	array::array() noexcept
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_ARRAY_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::~array() noexcept
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_ARRAY_DESTROYED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::array(const impl::array_init_elem* b, const impl::array_init_elem* e)
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_ARRAY_CREATED;
-#endif
-
-		TOML_ASSERT_ASSUME(b);
-		TOML_ASSERT_ASSUME(e);
-		TOML_ASSERT_ASSUME(b <= e);
-
-		if TOML_UNLIKELY(b == e)
-			return;
-
-		size_t cap{};
-		for (auto it = b; it != e; it++)
-		{
-			if (it->value)
-				cap++;
-		}
-		if TOML_UNLIKELY(!cap)
-			return;
-
-		elems_.reserve(cap);
-		for (; b != e; b++)
-		{
-			if (b->value)
-				elems_.push_back(std::move(b->value));
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::array(const array& other) //
-		: node(other)
-	{
-		elems_.reserve(other.elems_.size());
-		for (const auto& elem : other)
-			elems_.emplace_back(impl::make_node(elem));
-
-#if TOML_LIFETIME_HOOKS
-		TOML_ARRAY_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::array(array && other) noexcept //
-		: node(std::move(other)),
-		  elems_(std::move(other.elems_))
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_ARRAY_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array& array::operator=(const array& rhs)
-	{
-		if (&rhs != this)
-		{
-			node::operator=(rhs);
-			elems_.clear();
-			elems_.reserve(rhs.elems_.size());
-			for (const auto& elem : rhs)
-				elems_.emplace_back(impl::make_node(elem));
-		}
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array& array::operator=(array&& rhs) noexcept
-	{
-		if (&rhs != this)
-		{
-			node::operator=(std::move(rhs));
-			elems_ = std::move(rhs.elems_);
-		}
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::preinsertion_resize(size_t idx, size_t count)
-	{
-		TOML_ASSERT(idx <= elems_.size());
-		TOML_ASSERT_ASSUME(count >= 1u);
-		const auto old_size			= elems_.size();
-		const auto new_size			= old_size + count;
-		const auto inserting_at_end = idx == old_size;
-		elems_.resize(new_size);
-		if (!inserting_at_end)
-		{
-			for (size_t left = old_size, right = new_size - 1u; left-- > idx; right--)
-				elems_[right] = std::move(elems_[left]);
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::insert_at_back(impl::node_ptr && elem)
-	{
-		TOML_ASSERT(elem);
-		elems_.push_back(std::move(elem));
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::vector_iterator array::insert_at(const_vector_iterator pos, impl::node_ptr && elem)
-	{
-		return elems_.insert(pos, std::move(elem));
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool array::is_homogeneous(node_type ntype) const noexcept
-	{
-		if (elems_.empty())
-			return false;
-
-		if (ntype == node_type::none)
-			ntype = elems_[0]->type();
-
-		for (const auto& val : elems_)
-			if (val->type() != ntype)
-				return false;
-
-		return true;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool array::is_homogeneous(node_type ntype, node * &first_nonmatch) noexcept
-	{
-		if (elems_.empty())
-		{
-			first_nonmatch = {};
-			return false;
-		}
-		if (ntype == node_type::none)
-			ntype = elems_[0]->type();
-		for (const auto& val : elems_)
-		{
-			if (val->type() != ntype)
-			{
-				first_nonmatch = val.get();
-				return false;
-			}
-		}
-		return true;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool array::is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept
-	{
-		node* fnm		  = nullptr;
-		const auto result = const_cast<array&>(*this).is_homogeneous(ntype, fnm);
-		first_nonmatch	  = fnm;
-		return result;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node& array::at(size_t index)
-	{
-#if TOML_COMPILER_HAS_EXCEPTIONS
-
-		return *elems_.at(index);
-
-#else
-
-		auto n = get(index);
-		TOML_ASSERT_ASSUME(n && "element index not found in array!");
-		return *n;
-
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::reserve(size_t new_capacity)
-	{
-		elems_.reserve(new_capacity);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::shrink_to_fit()
-	{
-		elems_.shrink_to_fit();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::truncate(size_t new_size)
-	{
-		if (new_size < elems_.size())
-			elems_.resize(new_size);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::iterator array::erase(const_iterator pos) noexcept
-	{
-		return iterator{ elems_.erase(const_vector_iterator{ pos }) };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array::iterator array::erase(const_iterator first, const_iterator last) noexcept
-	{
-		return iterator{ elems_.erase(const_vector_iterator{ first }, const_vector_iterator{ last }) };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	size_t array::total_leaf_count() const noexcept
-	{
-		size_t leaves{};
-		for (size_t i = 0, e = elems_.size(); i < e; i++)
-		{
-			auto arr = elems_[i]->as_array();
-			leaves += arr ? arr->total_leaf_count() : size_t{ 1 };
-		}
-		return leaves;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::flatten_child(array && child, size_t & dest_index) noexcept
-	{
-		for (size_t i = 0, e = child.size(); i < e; i++)
-		{
-			auto type = child.elems_[i]->type();
-			if (type == node_type::array)
-			{
-				array& arr = *reinterpret_cast<array*>(child.elems_[i].get());
-				if (!arr.empty())
-					flatten_child(std::move(arr), dest_index);
-			}
-			else
-				elems_[dest_index++] = std::move(child.elems_[i]);
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array& array::flatten()&
-	{
-		if (elems_.empty())
-			return *this;
-
-		bool requires_flattening	 = false;
-		size_t size_after_flattening = elems_.size();
-		for (size_t i = elems_.size(); i-- > 0u;)
-		{
-			auto arr = elems_[i]->as_array();
-			if (!arr)
-				continue;
-			size_after_flattening--; // discount the array itself
-			const auto leaf_count = arr->total_leaf_count();
-			if (leaf_count > 0u)
-			{
-				requires_flattening = true;
-				size_after_flattening += leaf_count;
-			}
-			else
-				elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
-		}
-
-		if (!requires_flattening)
-			return *this;
-
-		elems_.reserve(size_after_flattening);
-
-		size_t i = 0;
-		while (i < elems_.size())
-		{
-			auto arr = elems_[i]->as_array();
-			if (!arr)
-			{
-				i++;
-				continue;
-			}
-
-			impl::node_ptr arr_storage = std::move(elems_[i]);
-			const auto leaf_count	   = arr->total_leaf_count();
-			if (leaf_count > 1u)
-				preinsertion_resize(i + 1u, leaf_count - 1u);
-			flatten_child(std::move(*arr), i); // increments i
-		}
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	array& array::prune(bool recursive)& noexcept
-	{
-		if (elems_.empty())
-			return *this;
-
-		for (size_t i = elems_.size(); i-- > 0u;)
-		{
-			if (auto arr = elems_[i]->as_array())
-			{
-				if (recursive)
-					arr->prune(true);
-				if (arr->empty())
-					elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
-			}
-			else if (auto tbl = elems_[i]->as_table())
-			{
-				if (recursive)
-					tbl->prune(true);
-				if (tbl->empty())
-					elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
-			}
-		}
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::pop_back() noexcept
-	{
-		elems_.pop_back();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void array::clear() noexcept
-	{
-		elems_.clear();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV array::equal(const array& lhs, const array& rhs) noexcept
-	{
-		if (&lhs == &rhs)
-			return true;
-		if (lhs.elems_.size() != rhs.elems_.size())
-			return false;
-		for (size_t i = 0, e = lhs.elems_.size(); i < e; i++)
-		{
-			const auto lhs_type = lhs.elems_[i]->type();
-			const node& rhs_	= *rhs.elems_[i];
-			const auto rhs_type = rhs_.type();
-			if (lhs_type != rhs_type)
-				return false;
-
-			const bool equal = lhs.elems_[i]->visit(
-				[&](const auto& lhs_) noexcept
-				{ return lhs_ == *reinterpret_cast<std::remove_reference_t<decltype(lhs_)>*>(&rhs_); });
-			if (!equal)
-				return false;
-		}
-		return true;
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/table.inl  ********************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	table::table() noexcept
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_TABLE_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::~table() noexcept
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_TABLE_DESTROYED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::table(const impl::table_init_pair* b, const impl::table_init_pair* e)
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_TABLE_CREATED;
-#endif
-
-		TOML_ASSERT_ASSUME(b);
-		TOML_ASSERT_ASSUME(e);
-		TOML_ASSERT_ASSUME(b <= e);
-
-		if TOML_UNLIKELY(b == e)
-			return;
-
-		for (; b != e; b++)
-		{
-			if (!b->value) // empty node_views
-				continue;
-
-			map_.insert_or_assign(std::move(b->key), std::move(b->value));
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::table(const table& other) //
-		: node(other),
-		  inline_{ other.inline_ }
-	{
-		for (auto&& [k, v] : other.map_)
-			map_.emplace_hint(map_.end(), k, impl::make_node(*v));
-
-#if TOML_LIFETIME_HOOKS
-		TOML_TABLE_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::table(table && other) noexcept //
-		: node(std::move(other)),
-		  map_{ std::move(other.map_) },
-		  inline_{ other.inline_ }
-	{
-#if TOML_LIFETIME_HOOKS
-		TOML_TABLE_CREATED;
-#endif
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table& table::operator=(const table& rhs)
-	{
-		if (&rhs != this)
-		{
-			node::operator=(rhs);
-			map_.clear();
-			for (auto&& [k, v] : rhs.map_)
-				map_.emplace_hint(map_.end(), k, impl::make_node(*v));
-			inline_ = rhs.inline_;
-		}
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table& table::operator=(table&& rhs) noexcept
-	{
-		if (&rhs != this)
-		{
-			node::operator=(std::move(rhs));
-			map_	= std::move(rhs.map_);
-			inline_ = rhs.inline_;
-		}
-		return *this;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool table::is_homogeneous(node_type ntype) const noexcept
-	{
-		if (map_.empty())
-			return false;
-
-		if (ntype == node_type::none)
-			ntype = map_.cbegin()->second->type();
-
-		for (auto&& [k, v] : map_)
-		{
-			TOML_UNUSED(k);
-			if (v->type() != ntype)
-				return false;
-		}
-
-		return true;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool table::is_homogeneous(node_type ntype, node * &first_nonmatch) noexcept
-	{
-		if (map_.empty())
-		{
-			first_nonmatch = {};
-			return false;
-		}
-		if (ntype == node_type::none)
-			ntype = map_.cbegin()->second->type();
-		for (const auto& [k, v] : map_)
-		{
-			TOML_UNUSED(k);
-			if (v->type() != ntype)
-			{
-				first_nonmatch = v.get();
-				return false;
-			}
-		}
-		return true;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool table::is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept
-	{
-		node* fnm		  = nullptr;
-		const auto result = const_cast<table&>(*this).is_homogeneous(ntype, fnm);
-		first_nonmatch	  = fnm;
-		return result;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	node* table::get(std::string_view key) noexcept
-	{
-		if (auto it = map_.find(key); it != map_.end())
-			return it->second.get();
-		return nullptr;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node& table::at(std::string_view key)
-	{
-		auto n = get(key);
-
-#if TOML_COMPILER_HAS_EXCEPTIONS
-
-		if (!n)
-		{
-			auto err = "key '"s;
-			err.append(key);
-			err.append("' not found in table"sv);
-			throw std::out_of_range{ err };
-		}
-
-#else
-
-		TOML_ASSERT_ASSUME(n && "key not found in table!");
-
-#endif
-
-		return *n;
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	table::map_iterator table::get_lower_bound(std::string_view key) noexcept
-	{
-		return map_.lower_bound(key);
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	table::iterator table::find(std::string_view key) noexcept
-	{
-		return iterator{ map_.find(key) };
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	table::const_iterator table::find(std::string_view key) const noexcept
-	{
-		return const_iterator{ map_.find(key) };
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::map_iterator table::erase(const_map_iterator pos) noexcept
-	{
-		return map_.erase(pos);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::map_iterator table::erase(const_map_iterator begin, const_map_iterator end) noexcept
-	{
-		return map_.erase(begin, end);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	size_t table::erase(std::string_view key) noexcept
-	{
-		if (auto it = map_.find(key); it != map_.end())
-		{
-			map_.erase(it);
-			return size_t{ 1 };
-		}
-		return size_t{};
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table& table::prune(bool recursive)& noexcept
-	{
-		if (map_.empty())
-			return *this;
-
-		for (auto it = map_.begin(); it != map_.end();)
-		{
-			if (auto arr = it->second->as_array())
-			{
-				if (recursive)
-					arr->prune(true);
-
-				if (arr->empty())
-				{
-					it = map_.erase(it);
-					continue;
-				}
-			}
-			else if (auto tbl = it->second->as_table())
-			{
-				if (recursive)
-					tbl->prune(true);
-
-				if (tbl->empty())
-				{
-					it = map_.erase(it);
-					continue;
-				}
-			}
-			it++;
-		}
-
-		return *this;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void table::clear() noexcept
-	{
-		map_.clear();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	table::map_iterator table::insert_with_hint(const_iterator hint, key && k, impl::node_ptr && v)
-	{
-		return map_.emplace_hint(const_map_iterator{ hint }, std::move(k), std::move(v));
-	}
-
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool TOML_CALLCONV table::equal(const table& lhs, const table& rhs) noexcept
-	{
-		if (&lhs == &rhs)
-			return true;
-		if (lhs.map_.size() != rhs.map_.size())
-			return false;
-
-		for (auto l = lhs.map_.begin(), r = rhs.map_.begin(), e = lhs.map_.end(); l != e; l++, r++)
-		{
-			if (l->first != r->first)
-				return false;
-
-			const auto lhs_type = l->second->type();
-			const node& rhs_	= *r->second;
-			const auto rhs_type = rhs_.type();
-			if (lhs_type != rhs_type)
-				return false;
-
-			const bool equal = l->second->visit(
-				[&](const auto& lhs_) noexcept
-				{ return lhs_ == *reinterpret_cast<std::remove_reference_t<decltype(lhs_)>*>(&rhs_); });
-			if (!equal)
-				return false;
-		}
-		return true;
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/simd.h  ***********************************************************************************************
-
-#if TOML_ENABLE_SIMD
-
-#if defined(__SSE2__)                                                                                                  \
-	|| (defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)))
-#define TOML_HAS_SSE2 1
-#endif
-
-#if defined(__SSE4_1__) || (defined(_MSC_VER) && (defined(__AVX__) || defined(__AVX2__)))
-#define TOML_HAS_SSE4_1 1
-#endif
-
-#endif // TOML_ENABLE_SIMD
-
-#ifndef TOML_HAS_SSE2
-#define TOML_HAS_SSE2 0
-#endif
-#ifndef TOML_HAS_SSE4_1
-#define TOML_HAS_SSE4_1 0
-#endif
-
-TOML_DISABLE_WARNINGS;
-#if TOML_HAS_SSE4_1
-#include <smmintrin.h>
-#endif
-#if TOML_HAS_SSE2
-#include <emmintrin.h>
-#endif
-TOML_ENABLE_WARNINGS;
-
-//********  impl/unicode.inl  ******************************************************************************************
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_PURE_GETTER
-	TOML_EXTERNAL_LINKAGE
-	bool is_ascii(const char* str, size_t len) noexcept
-	{
-		const char* const end = str + len;
-
-#if TOML_HAS_SSE2 && (128 % CHAR_BIT) == 0
-		{
-			constexpr size_t chars_per_vector = 128u / CHAR_BIT;
-
-			if (const size_t simdable = len - (len % chars_per_vector))
-			{
-				__m128i mask = _mm_setzero_si128();
-				for (const char* const e = str + simdable; str < e; str += chars_per_vector)
-				{
-					const __m128i current_bytes = _mm_loadu_si128(reinterpret_cast<const __m128i*>(str));
-					mask						= _mm_or_si128(mask, current_bytes);
-				}
-				const __m128i has_error = _mm_cmpgt_epi8(_mm_setzero_si128(), mask);
-
-#if TOML_HAS_SSE4_1
-				if (!_mm_testz_si128(has_error, has_error))
-					return false;
-#else
-				if (_mm_movemask_epi8(_mm_cmpeq_epi8(has_error, _mm_setzero_si128())) != 0xFFFF)
-					return false;
-#endif
-			}
-		}
-#endif
-
-		for (; str < end; str++)
-			if (static_cast<unsigned char>(*str) > 127u)
-				return false;
-
-		return true;
-	}
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-//********  impl/parser.inl  *******************************************************************************************
-
-#if TOML_ENABLE_PARSER
-
-TOML_DISABLE_WARNINGS;
-#include <istream>
-#include <fstream>
-#if TOML_INT_CHARCONV || TOML_FLOAT_CHARCONV
-#include <charconv>
-#endif
-#if !TOML_INT_CHARCONV || !TOML_FLOAT_CHARCONV
-#include <sstream>
-#endif
-#if !TOML_INT_CHARCONV
-#include <iomanip>
-#endif
-TOML_ENABLE_WARNINGS;
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_ANON_NAMESPACE_START
-{
-	template <typename T>
-	class utf8_byte_stream;
-
-	TOML_INTERNAL_LINKAGE
-	constexpr auto utf8_byte_order_mark = "\xEF\xBB\xBF"sv;
-
-	template <typename Char>
-	class utf8_byte_stream<std::basic_string_view<Char>>
-	{
-		static_assert(sizeof(Char) == 1);
-
-	  private:
-		std::basic_string_view<Char> source_;
-		size_t position_ = {};
-
-	  public:
-		TOML_NODISCARD_CTOR
-		explicit constexpr utf8_byte_stream(std::basic_string_view<Char> sv) noexcept //
-			: source_{ sv }
-		{
-			// skip bom
-			if (source_.length() >= 3u && memcmp(utf8_byte_order_mark.data(), source_.data(), 3u) == 0)
-				position_ += 3u;
-		}
-
-		TOML_CONST_INLINE_GETTER
-		constexpr bool error() const noexcept
-		{
-			return false;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool eof() const noexcept
-		{
-			return position_ >= source_.length();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit constexpr operator bool() const noexcept
-		{
-			return !eof();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr bool peek_eof() const noexcept
-		{
-			return eof();
-		}
-
-		TOML_NODISCARD
-		TOML_ATTR(nonnull)
-		size_t operator()(void* dest, size_t num) noexcept
-		{
-			TOML_ASSERT_ASSUME(!eof());
-
-			num = impl::min(position_ + num, source_.length()) - position_;
-			std::memcpy(dest, source_.data() + position_, num);
-			position_ += num;
-			return num;
-		}
-	};
-
-	template <>
-	class utf8_byte_stream<std::istream>
-	{
-	  private:
-		std::istream* source_;
-
-	  public:
-		TOML_NODISCARD_CTOR
-		explicit utf8_byte_stream(std::istream& stream) noexcept(!TOML_COMPILER_HAS_EXCEPTIONS) //
-			: source_{ &stream }
-		{
-			if (!*this) // eof, bad
-				return;
-
-			const auto initial_pos = source_->tellg();
-			char bom[3];
-			source_->read(bom, 3);
-			if (source_->bad() || (source_->gcount() == 3 && memcmp(utf8_byte_order_mark.data(), bom, 3u) == 0))
-				return;
-
-			source_->clear();
-			source_->seekg(initial_pos, std::istream::beg);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool error() const noexcept
-		{
-			return !!(source_->rdstate() & std::istream::badbit);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool eof() const noexcept
-		{
-			return !!(source_->rdstate() & std::istream::eofbit);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		explicit operator bool() const noexcept
-		{
-			return !(source_->rdstate() & (std::istream::badbit | std::istream::eofbit));
-		}
-
-		TOML_NODISCARD
-		bool peek_eof() const noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-		{
-			return eof() || source_->peek() == std::istream::traits_type::eof();
-		}
-
-		TOML_NODISCARD
-		TOML_ATTR(nonnull)
-		size_t operator()(void* dest, size_t num) noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-		{
-			TOML_ASSERT(*this);
-
-			source_->read(static_cast<char*>(dest), static_cast<std::streamsize>(num));
-			return static_cast<size_t>(source_->gcount());
-		}
-	};
-
-	struct utf8_codepoint
-	{
-		char32_t value;
-		char bytes[4];
-		size_t count;
-		source_position position;
-
-		TOML_PURE_INLINE_GETTER
-		constexpr operator const char32_t&() const noexcept
-		{
-			return value;
-		}
-
-		TOML_PURE_INLINE_GETTER
-		constexpr const char32_t& operator*() const noexcept
-		{
-			return value;
-		}
-	};
-	static_assert(std::is_trivial_v<utf8_codepoint>);
-	static_assert(std::is_standard_layout_v<utf8_codepoint>);
-
-	struct TOML_ABSTRACT_INTERFACE utf8_reader_interface
-	{
-		TOML_NODISCARD
-		virtual const source_path_ptr& source_path() const noexcept = 0;
-
-		TOML_NODISCARD
-		virtual const utf8_codepoint* read_next() noexcept(!TOML_COMPILER_HAS_EXCEPTIONS) = 0;
-
-		TOML_NODISCARD
-		virtual bool peek_eof() const noexcept(!TOML_COMPILER_HAS_EXCEPTIONS) = 0;
-
-#if !TOML_EXCEPTIONS
-
-		TOML_NODISCARD
-		virtual optional<parse_error>&& error() noexcept = 0;
-
-#endif
-
-		virtual ~utf8_reader_interface() noexcept = default;
-	};
-
-#if TOML_EXCEPTIONS
-#define utf8_reader_error(...)				throw parse_error(__VA_ARGS__)
-#define utf8_reader_return_after_error(...) static_assert(true)
-#define utf8_reader_error_check(...)		static_assert(true)
-#else
-#define utf8_reader_error(...)				err_.emplace(__VA_ARGS__)
-#define utf8_reader_return_after_error(...) return __VA_ARGS__
-#define utf8_reader_error_check(...)                                                                                   \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(err_)                                                                                         \
-			return __VA_ARGS__;                                                                                        \
-	}                                                                                                                  \
-	while (false)
-
-#endif
-
-#if defined(__APPLE__) || defined(__MINGW32__) || defined(__MINGW64__)
-#define TOML_OVERALIGNED
-#else
-#define TOML_OVERALIGNED alignas(32)
-#endif
-
-	template <typename T>
-	class TOML_EMPTY_BASES utf8_reader final : public utf8_reader_interface
-	{
-	  private:
-		static constexpr size_t block_capacity = 32;
-		utf8_byte_stream<T> stream_;
-		source_position next_pos_ = { 1, 1 };
-
-		impl::utf8_decoder decoder_;
-		struct currently_decoding_t
-		{
-			char bytes[4];
-			size_t count;
-		} currently_decoding_;
-
-		struct codepoints_t
-		{
-			TOML_OVERALIGNED utf8_codepoint buffer[block_capacity];
-			size_t current;
-			size_t count;
-		} codepoints_;
-
-		source_path_ptr source_path_;
-
-#if !TOML_EXCEPTIONS
-		optional<parse_error> err_;
-#endif
-
-		bool read_next_block() noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-		{
-			TOML_ASSERT(stream_);
-
-			TOML_OVERALIGNED char raw_bytes[block_capacity];
-			size_t raw_bytes_read;
-
-			// read the next raw (encoded) block in from the stream
-			if constexpr (noexcept(stream_(raw_bytes, block_capacity)) || !TOML_EXCEPTIONS)
-			{
-				raw_bytes_read = stream_(raw_bytes, block_capacity);
-			}
-#if TOML_EXCEPTIONS
-			else
-			{
-				try
-				{
-					raw_bytes_read = stream_(raw_bytes, block_capacity);
-				}
-				catch (const std::exception& exc)
-				{
-					throw parse_error{ exc.what(), next_pos_, source_path_ };
-				}
-				catch (...)
-				{
-					throw parse_error{ "An unspecified error occurred", next_pos_, source_path_ };
-				}
-			}
-#endif // TOML_EXCEPTIONS
-
-			// handle a zero-byte read
-			if TOML_UNLIKELY(!raw_bytes_read)
-			{
-				if (stream_.eof())
-				{
-					// EOF only sets the error state if the decoder wants more input, otherwise
-					// a zero-byte read might have just caused the underlying stream to realize it's exhaused and set
-					// the EOF flag, and that's totally fine
-					if (decoder_.needs_more_input())
-						utf8_reader_error("Encountered EOF during incomplete utf-8 code point sequence",
-										  next_pos_,
-										  source_path_);
-				}
-				else
-				{
-					utf8_reader_error("Reading from the underlying stream failed - zero bytes read",
-									  next_pos_,
-									  source_path_);
-				}
-				return false;
-			}
-
-			TOML_ASSERT_ASSUME(raw_bytes_read);
-			std::memset(&codepoints_, 0, sizeof(codepoints_));
-
-			// helper for calculating decoded codepoint line+cols
-			const auto calc_positions = [&]() noexcept
-			{
-				for (size_t i = 0; i < codepoints_.count; i++)
-				{
-					auto& cp	= codepoints_.buffer[i];
-					cp.position = next_pos_;
-
-					if (cp == U'\n')
-					{
-						next_pos_.line++;
-						next_pos_.column = source_index{ 1 };
-					}
-					else
-						next_pos_.column++;
-				}
-			};
-
-			// decide whether we need to use the UTF-8 decoder or if we can treat this block as plain ASCII
-			const auto ascii_fast_path = !decoder_.needs_more_input() && impl::is_ascii(raw_bytes, raw_bytes_read);
-
-			// ASCII fast-path
-			if (ascii_fast_path)
-			{
-				decoder_.reset();
-				currently_decoding_.count = {};
-
-				codepoints_.count = raw_bytes_read;
-				for (size_t i = 0; i < codepoints_.count; i++)
-				{
-					auto& cp	= codepoints_.buffer[i];
-					cp.value	= static_cast<char32_t>(raw_bytes[i]);
-					cp.bytes[0] = raw_bytes[i];
-					cp.count	= 1u;
-				}
-			}
-
-			// UTF-8 slow-path
-			else
-			{
-				// helper for getting precise error location
-				const auto error_pos = [&]() noexcept -> const source_position&
-				{ //
-					return codepoints_.count ? codepoints_.buffer[codepoints_.count - 1u].position : next_pos_;
-				};
-
-				for (size_t i = 0; i < raw_bytes_read; i++)
-				{
-					decoder_(static_cast<uint8_t>(raw_bytes[i]));
-					if TOML_UNLIKELY(decoder_.error())
-					{
-						calc_positions();
-						utf8_reader_error("Encountered invalid utf-8 sequence", error_pos(), source_path_);
-						utf8_reader_return_after_error(false);
-					}
-
-					currently_decoding_.bytes[currently_decoding_.count++] = raw_bytes[i];
-
-					if (decoder_.has_code_point())
-					{
-						auto& cp = codepoints_.buffer[codepoints_.count++];
-
-						cp.value = decoder_.codepoint;
-						cp.count = currently_decoding_.count;
-						std::memcpy(cp.bytes, currently_decoding_.bytes, currently_decoding_.count);
-						currently_decoding_.count = {};
-					}
-					else if TOML_UNLIKELY(currently_decoding_.count == 4u)
-					{
-						calc_positions();
-						utf8_reader_error("Encountered overlong utf-8 sequence", error_pos(), source_path_);
-						utf8_reader_return_after_error(false);
-					}
-				}
-				if TOML_UNLIKELY(decoder_.needs_more_input() && stream_.eof())
-				{
-					calc_positions();
-					utf8_reader_error("Encountered EOF during incomplete utf-8 code point sequence",
-									  error_pos(),
-									  source_path_);
-					utf8_reader_return_after_error(false);
-				}
-			}
-
-			TOML_ASSERT_ASSUME(codepoints_.count);
-			calc_positions();
-
-			// handle general I/O errors
-			// (down here so the next_pos_ benefits from calc_positions())
-			if TOML_UNLIKELY(stream_.error())
-			{
-				utf8_reader_error("An I/O error occurred while reading from the underlying stream",
-								  next_pos_,
-								  source_path_);
-				utf8_reader_return_after_error(false);
-			}
-
-			return true;
-		}
-
-	  public:
-		template <typename U, typename String = std::string_view>
-		TOML_NODISCARD_CTOR
-		explicit utf8_reader(U&& source, String&& source_path = {}) noexcept(
-			std::is_nothrow_constructible_v<utf8_byte_stream<T>, U&&>)
-			: stream_{ static_cast<U&&>(source) }
-		{
-			currently_decoding_.count = {};
-
-			codepoints_.current = {};
-			codepoints_.count	= {};
-
-			if (!source_path.empty())
-				source_path_ = std::make_shared<const std::string>(static_cast<String&&>(source_path));
-		}
-
-		TOML_PURE_INLINE_GETTER
-		const source_path_ptr& source_path() const noexcept final
-		{
-			return source_path_;
-		}
-
-		TOML_NODISCARD
-		const utf8_codepoint* read_next() noexcept(!TOML_COMPILER_HAS_EXCEPTIONS) final
-		{
-			utf8_reader_error_check({});
-
-			if (codepoints_.current == codepoints_.count)
-			{
-				if TOML_UNLIKELY(!stream_ || !read_next_block())
-					return nullptr;
-
-				TOML_ASSERT_ASSUME(!codepoints_.current);
-			}
-			TOML_ASSERT_ASSUME(codepoints_.count);
-			TOML_ASSERT_ASSUME(codepoints_.count <= block_capacity);
-			TOML_ASSERT_ASSUME(codepoints_.current < codepoints_.count);
-
-			return &codepoints_.buffer[codepoints_.current++];
-		}
-
-		TOML_NODISCARD
-		bool peek_eof() const noexcept(!TOML_COMPILER_HAS_EXCEPTIONS) final
-		{
-			return stream_.peek_eof();
-		}
-
-#if !TOML_EXCEPTIONS
-
-		TOML_NODISCARD
-		optional<parse_error>&& error() noexcept final
-		{
-			return std::move(err_);
-		}
-
-#endif
-	};
-
-	template <typename Char>
-	utf8_reader(std::basic_string_view<Char>, std::string_view) -> utf8_reader<std::basic_string_view<Char>>;
-	template <typename Char>
-	utf8_reader(std::basic_string_view<Char>, std::string &&) -> utf8_reader<std::basic_string_view<Char>>;
-	template <typename Char>
-	utf8_reader(std::basic_istream<Char>&, std::string_view) -> utf8_reader<std::basic_istream<Char>>;
-	template <typename Char>
-	utf8_reader(std::basic_istream<Char>&, std::string &&) -> utf8_reader<std::basic_istream<Char>>;
-
-#if TOML_EXCEPTIONS
-#define utf8_buffered_reader_error_check(...) static_assert(true)
-#else
-#define utf8_buffered_reader_error_check(...)                                                                          \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(reader_.error())                                                                              \
-			return __VA_ARGS__;                                                                                        \
-	}                                                                                                                  \
-	while (false)
-
-#endif
-
-	class TOML_EMPTY_BASES utf8_buffered_reader
-	{
-	  public:
-		static constexpr size_t max_history_length = 128;
-
-	  private:
-		static constexpr size_t history_buffer_size = max_history_length - 1; //'head' is stored in the reader
-		utf8_reader_interface& reader_;
-		struct
-		{
-			utf8_codepoint buffer[history_buffer_size];
-			size_t count, first;
-		} history_					= {};
-		const utf8_codepoint* head_ = {};
-		size_t negative_offset_		= {};
-
-	  public:
-		TOML_NODISCARD_CTOR
-		explicit utf8_buffered_reader(utf8_reader_interface& reader) noexcept //
-			: reader_{ reader }
-		{}
-
-		TOML_PURE_INLINE_GETTER
-		const source_path_ptr& source_path() const noexcept
-		{
-			return reader_.source_path();
-		}
-
-		TOML_NODISCARD
-		const utf8_codepoint* read_next() noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-		{
-			utf8_buffered_reader_error_check({});
-
-			if (negative_offset_)
-			{
-				negative_offset_--;
-
-				// an entry negative offset of 1 just means "replay the current head"
-				if (!negative_offset_)
-					return head_;
-
-				// otherwise step back into the history buffer
-				else
-					return history_.buffer
-						 + ((history_.first + history_.count - negative_offset_) % history_buffer_size);
-			}
-			else
-			{
-				// first character read from stream
-				if TOML_UNLIKELY(!history_.count && !head_)
-					head_ = reader_.read_next();
-
-				// subsequent characters and not eof
-				else if (head_)
-				{
-					if TOML_UNLIKELY(history_.count < history_buffer_size)
-						history_.buffer[history_.count++] = *head_;
-					else
-						history_.buffer[(history_.first++ + history_buffer_size) % history_buffer_size] = *head_;
-
-					head_ = reader_.read_next();
-				}
-
-				return head_;
-			}
-		}
-
-		TOML_NODISCARD
-		const utf8_codepoint* step_back(size_t count) noexcept
-		{
-			utf8_buffered_reader_error_check({});
-
-			TOML_ASSERT_ASSUME(history_.count);
-			TOML_ASSERT_ASSUME(negative_offset_ + count <= history_.count);
-
-			negative_offset_ += count;
-
-			return negative_offset_
-					 ? history_.buffer + ((history_.first + history_.count - negative_offset_) % history_buffer_size)
-					 : head_;
-		}
-
-		TOML_NODISCARD
-		bool peek_eof() const noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-		{
-			return reader_.peek_eof();
-		}
-
-#if !TOML_EXCEPTIONS
-
-		TOML_NODISCARD
-		optional<parse_error>&& error() noexcept
-		{
-			return reader_.error();
-		}
-
-#endif
-	};
-}
-TOML_ANON_NAMESPACE_END;
-
-#if TOML_EXCEPTIONS
-#define TOML_RETURNS_BY_THROWING [[noreturn]]
-#else
-#define TOML_RETURNS_BY_THROWING
-#endif
-
-TOML_ANON_NAMESPACE_START
-{
-	template <typename... T>
-	TOML_CONST_GETTER
-	TOML_INTERNAL_LINKAGE
-	constexpr bool is_match(char32_t codepoint, T... vals) noexcept
-	{
-		static_assert((std::is_same_v<char32_t, T> && ...));
-		return ((codepoint == vals) || ...);
-	}
-
-	template <uint64_t>
-	struct parse_integer_traits;
-	template <>
-	struct parse_integer_traits<2>
-	{
-		static constexpr auto scope_qualifier  = "binary integer"sv;
-		static constexpr auto is_digit		   = impl::is_binary_digit;
-		static constexpr auto is_signed		   = false;
-		static constexpr auto max_digits	   = 63;
-		static constexpr auto prefix_codepoint = U'b';
-		static constexpr auto prefix		   = "b"sv;
-		static constexpr auto full_prefix	   = "0b"sv;
-	};
-	template <>
-	struct parse_integer_traits<8>
-	{
-		static constexpr auto scope_qualifier  = "octal integer"sv;
-		static constexpr auto is_digit		   = impl::is_octal_digit;
-		static constexpr auto is_signed		   = false;
-		static constexpr auto max_digits	   = 21; // strlen("777777777777777777777")
-		static constexpr auto prefix_codepoint = U'o';
-		static constexpr auto prefix		   = "o"sv;
-		static constexpr auto full_prefix	   = "0o"sv;
-	};
-	template <>
-	struct parse_integer_traits<10>
-	{
-		static constexpr auto scope_qualifier = "decimal integer"sv;
-		static constexpr auto is_digit		  = impl::is_decimal_digit;
-		static constexpr auto is_signed		  = true;
-		static constexpr auto max_digits	  = 19; // strlen("9223372036854775807")
-		static constexpr auto full_prefix	  = ""sv;
-	};
-	template <>
-	struct parse_integer_traits<16>
-	{
-		static constexpr auto scope_qualifier  = "hexadecimal integer"sv;
-		static constexpr auto is_digit		   = impl::is_hexadecimal_digit;
-		static constexpr auto is_signed		   = false;
-		static constexpr auto max_digits	   = 16; // strlen("7FFFFFFFFFFFFFFF")
-		static constexpr auto prefix_codepoint = U'x';
-		static constexpr auto prefix		   = "x"sv;
-		static constexpr auto full_prefix	   = "0x"sv;
-	};
-
-	TOML_PURE_GETTER
-	TOML_INTERNAL_LINKAGE
-	std::string_view to_sv(node_type val) noexcept
-	{
-		return impl::node_type_friendly_names[impl::unwrap_enum(val)];
-	}
-
-	TOML_PURE_GETTER
-	TOML_INTERNAL_LINKAGE
-	std::string_view to_sv(const std::string& str) noexcept
-	{
-		return std::string_view{ str };
-	}
-
-	TOML_CONST_GETTER
-	TOML_INTERNAL_LINKAGE
-	std::string_view to_sv(bool val) noexcept
-	{
-		using namespace std::string_view_literals;
-
-		return val ? "true"sv : "false"sv;
-	}
-
-	TOML_PURE_GETTER
-	TOML_INTERNAL_LINKAGE
-	std::string_view to_sv(const utf8_codepoint& cp) noexcept
-	{
-		if (cp.value <= U'\x1F')
-			return impl::control_char_escapes[cp.value];
-		else if (cp.value == U'\x7F')
-			return "\\u007F"sv;
-		else
-			return std::string_view{ cp.bytes, cp.count };
-	}
-
-	TOML_PURE_GETTER
-	TOML_INTERNAL_LINKAGE
-	std::string_view to_sv(const utf8_codepoint* cp) noexcept
-	{
-		if (cp)
-			return to_sv(*cp);
-		return ""sv;
-	}
-
-	struct escaped_codepoint
-	{
-		const utf8_codepoint& cp;
-	};
-
-	template <typename T>
-	TOML_ATTR(nonnull)
-	TOML_INTERNAL_LINKAGE
-	void concatenate(char*& write_pos, char* const buf_end, const T& arg) noexcept
-	{
-		if TOML_UNLIKELY(write_pos >= buf_end)
-			return;
-
-		using arg_type = impl::remove_cvref<T>;
-
-		// string views
-		if constexpr (std::is_same_v<arg_type, std::string_view>)
-		{
-			const auto max_chars = static_cast<size_t>(buf_end - write_pos);
-			const auto len		 = max_chars < arg.length() ? max_chars : arg.length();
-			std::memcpy(write_pos, arg.data(), len);
-			write_pos += len;
-		}
-
-		// doubles
-		else if constexpr (std::is_same_v<arg_type, double>)
-		{
-#if TOML_FLOAT_CHARCONV
-			const auto result = std::to_chars(write_pos, buf_end, arg);
-			write_pos		  = result.ptr;
-#else
-			std::ostringstream ss;
-			ss.imbue(std::locale::classic());
-			ss.precision(std::numeric_limits<arg_type>::max_digits10);
-			ss << arg;
-			concatenate(write_pos, buf_end, to_sv(std::move(ss).str()));
-#endif
-		}
-
-		// 64-bit integers
-		else if constexpr (impl::is_one_of<arg_type, int64_t, uint64_t>)
-		{
-#if TOML_INT_CHARCONV
-			const auto result = std::to_chars(write_pos, buf_end, arg);
-			write_pos		  = result.ptr;
-#else
-			std::ostringstream ss;
-			ss.imbue(std::locale::classic());
-			using cast_type = std::conditional_t<std::is_signed_v<arg_type>, int64_t, uint64_t>;
-			ss << static_cast<cast_type>(arg);
-			concatenate(write_pos, buf_end, to_sv(std::move(ss).str()));
-#endif
-		}
-
-		// escaped_codepoint
-		else if constexpr (std::is_same_v<arg_type, escaped_codepoint>)
-		{
-			if (arg.cp.value <= U'\x7F')
-				concatenate(write_pos, buf_end, to_sv(arg.cp));
-			else
-			{
-				auto val			= static_cast<uint_least32_t>(arg.cp.value);
-				const auto digits	= val > 0xFFFFu ? 8u : 4u;
-				constexpr auto mask = uint_least32_t{ 0xFu };
-				char buf[10]		= { '\\', digits > 4 ? 'U' : 'u' };
-				for (auto i = 2u + digits; i-- > 2u;)
-				{
-					const auto hexdig = val & mask;
-					buf[i]			  = static_cast<char>(hexdig >= 0xAu ? ('A' + (hexdig - 0xAu)) : ('0' + hexdig));
-					val >>= 4;
-				}
-				concatenate(write_pos, buf_end, std::string_view{ buf, digits + 2u });
-			}
-		}
-
-		// all other floats (fallback - coerce to double)
-		else if constexpr (std::is_floating_point_v<arg_type>)
-			concatenate(write_pos, buf_end, static_cast<double>(arg));
-
-		// all other integers (fallback - coerce to (u)int64_t)
-		else if constexpr (std::is_arithmetic_v<arg_type> && std::is_integral_v<arg_type>)
-		{
-			using cast_type = std::conditional_t<std::is_unsigned_v<arg_type>, uint64_t, int64_t>;
-			concatenate(write_pos, buf_end, static_cast<cast_type>(arg));
-		}
-
-		else
-		{
-			static_assert(
-				impl::dependent_false<T>,
-				"concatenate() inputs are limited to std::string_views, integers, floats, and escaped_codepoint");
-		}
-	}
-
-	struct error_builder
-	{
-		static constexpr std::size_t buf_size = 512;
-		char buf[buf_size];
-		char* write_pos			  = buf;
-		char* const max_write_pos = buf + (buf_size - std::size_t{ 1 }); // allow for null terminator
-
-		TOML_NODISCARD_CTOR
-		error_builder(std::string_view scope) noexcept
-		{
-			concatenate(write_pos, max_write_pos, "Error while parsing "sv);
-			concatenate(write_pos, max_write_pos, scope);
-			concatenate(write_pos, max_write_pos, ": "sv);
-		}
-
-		template <typename T>
-		void append(const T& arg) noexcept
-		{
-			concatenate(write_pos, max_write_pos, arg);
-		}
-
-		TOML_RETURNS_BY_THROWING
-		auto finish(const source_position& pos, const source_path_ptr& source_path) const
-		{
-			*write_pos = '\0';
-
-#if TOML_EXCEPTIONS
-			throw parse_error{ buf, pos, source_path };
-#else
-			return parse_error{ std::string(buf, static_cast<size_t>(write_pos - buf)), pos, source_path };
-#endif
-		}
-
-		TOML_DELETE_DEFAULTS(error_builder);
-	};
-
-	struct parse_scope
-	{
-		std::string_view& storage_;
-		std::string_view parent_;
-
-		TOML_NODISCARD_CTOR
-		explicit parse_scope(std::string_view& current_scope, std::string_view new_scope) noexcept
-			: storage_{ current_scope },
-			  parent_{ current_scope }
-		{
-			storage_ = new_scope;
-		}
-
-		~parse_scope() noexcept
-		{
-			storage_ = parent_;
-		}
-
-		TOML_DELETE_DEFAULTS(parse_scope);
-	};
-#define push_parse_scope_2(scope, line) parse_scope ps_##line(current_scope, scope)
-#define push_parse_scope_1(scope, line) push_parse_scope_2(scope, line)
-#define push_parse_scope(scope)			push_parse_scope_1(scope, __LINE__)
-
-	struct parse_key_buffer
-	{
-		std::string buffer;
-		std::vector<std::pair<size_t, size_t>> segments;
-		std::vector<source_position> starts;
-		std::vector<source_position> ends;
-
-		void clear() noexcept
-		{
-			buffer.clear();
-			segments.clear();
-			starts.clear();
-			ends.clear();
-		}
-
-		void push_back(std::string_view segment, source_position b, source_position e)
-		{
-			segments.push_back({ buffer.length(), segment.length() });
-			buffer.append(segment);
-			starts.push_back(b);
-			ends.push_back(e);
-		}
-
-		TOML_PURE_INLINE_GETTER
-		std::string_view operator[](size_t i) const noexcept
-		{
-			return std::string_view{ buffer.c_str() + segments[i].first, segments[i].second };
-		}
-
-		TOML_PURE_INLINE_GETTER
-		std::string_view back() const noexcept
-		{
-			return (*this)[segments.size() - 1u];
-		}
-
-		TOML_PURE_INLINE_GETTER
-		bool empty() const noexcept
-		{
-			return segments.empty();
-		}
-
-		TOML_PURE_INLINE_GETTER
-		size_t size() const noexcept
-		{
-			return segments.size();
-		}
-	};
-
-	struct depth_counter_scope
-	{
-		size_t& depth_;
-
-		TOML_NODISCARD_CTOR
-		explicit depth_counter_scope(size_t& depth) noexcept //
-			: depth_{ depth }
-		{
-			depth_++;
-		}
-
-		~depth_counter_scope() noexcept
-		{
-			depth_--;
-		}
-
-		TOML_DELETE_DEFAULTS(depth_counter_scope);
-	};
-
-	struct parsed_string
-	{
-		std::string_view value;
-		bool was_multi_line;
-	};
-
-	struct table_vector_scope
-	{
-		std::vector<table*>& tables;
-
-		TOML_NODISCARD_CTOR
-		explicit table_vector_scope(std::vector<table*>& tables_, table& tbl) //
-			: tables{ tables_ }
-		{
-			tables.push_back(&tbl);
-		}
-
-		~table_vector_scope() noexcept
-		{
-			tables.pop_back();
-		}
-
-		TOML_DELETE_DEFAULTS(table_vector_scope);
-	};
-}
-TOML_ANON_NAMESPACE_END;
-
-#if 1 // parser helper macros
-
-// Q: "what the fuck is this? MACROS????"
-// A: The parser needs to work in exceptionless mode (returning error objects directly)
-//    and exception mode (reporting parse failures by throwing). Two totally different control flows.
-//    These macros encapsulate the differences between the two modes so I can write code code
-//    as though I was only targeting one mode and not want yeet myself into the sun.
-//    They're all #undef'd at the bottom of the parser's implementation so they should be harmless outside
-//    of toml++.
-
-#define is_eof()		 !cp
-#define assert_not_eof() TOML_ASSERT_ASSUME(cp != nullptr)
-#define return_if_eof(...)                                                                                             \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(is_eof())                                                                                     \
-			return __VA_ARGS__;                                                                                        \
-	}                                                                                                                  \
-	while (false)
-
-#if TOML_EXCEPTIONS
-#define is_error()					false
-#define return_after_error(...)		TOML_UNREACHABLE
-#define assert_not_error()			static_assert(true)
-#define return_if_error(...)		static_assert(true)
-#define return_if_error_or_eof(...) return_if_eof(__VA_ARGS__)
-#else
-#define is_error()				!!err
-#define return_after_error(...) return __VA_ARGS__
-#define assert_not_error()		TOML_ASSERT(!is_error())
-#define return_if_error(...)                                                                                           \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(is_error())                                                                                   \
-			return __VA_ARGS__;                                                                                        \
-	}                                                                                                                  \
-	while (false)
-#define return_if_error_or_eof(...)                                                                                    \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(is_eof() || is_error())                                                                       \
-			return __VA_ARGS__;                                                                                        \
-	}                                                                                                                  \
-	while (false)
-#endif
-
-#if defined(TOML_BREAK_AT_PARSE_ERRORS) && TOML_BREAK_AT_PARSE_ERRORS
-#if defined(__has_builtin)
-#if __has_builtin(__builtin_debugtrap)
-#define parse_error_break() __builtin_debugtrap()
-#elif __has_builtin(__debugbreak)
-#define parse_error_break() __debugbreak()
-#endif
-#endif
-#ifndef parse_error_break
-#if TOML_MSVC || TOML_ICC
-#define parse_error_break() __debugbreak()
-#else
-#define parse_error_break() TOML_ASSERT(false)
-#endif
-#endif
-#else
-#define parse_error_break() static_assert(true)
-#endif
-
-#define set_error_and_return(ret, ...)                                                                                 \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if (!is_error())                                                                                               \
-			set_error(__VA_ARGS__);                                                                                    \
-		return_after_error(ret);                                                                                       \
-	}                                                                                                                  \
-	while (false)
-
-#define set_error_and_return_default(...) set_error_and_return({}, __VA_ARGS__)
-
-#define set_error_and_return_if_eof(...)                                                                               \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		if TOML_UNLIKELY(is_eof())                                                                                     \
-			set_error_and_return(__VA_ARGS__, "encountered end-of-file"sv);                                            \
-	}                                                                                                                  \
-	while (false)
-
-#define advance_and_return_if_error(...)                                                                               \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		assert_not_eof();                                                                                              \
-		advance();                                                                                                     \
-		return_if_error(__VA_ARGS__);                                                                                  \
-	}                                                                                                                  \
-	while (false)
-
-#define advance_and_return_if_error_or_eof(...)                                                                        \
-	do                                                                                                                 \
-	{                                                                                                                  \
-		assert_not_eof();                                                                                              \
-		advance();                                                                                                     \
-		return_if_error(__VA_ARGS__);                                                                                  \
-		set_error_and_return_if_eof(__VA_ARGS__);                                                                      \
-	}                                                                                                                  \
-	while (false)
-
-#endif // parser helper macros
-
-TOML_IMPL_NAMESPACE_START
-{
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, impl_ex, impl_noex);
-
-	class parser
-	{
-	  private:
-		static constexpr size_t max_nested_values = TOML_MAX_NESTED_VALUES;
-
-		utf8_buffered_reader reader;
-		table root;
-		source_position prev_pos = { 1, 1 };
-		const utf8_codepoint* cp = {};
-		std::vector<table*> implicit_tables;
-		std::vector<table*> dotted_key_tables;
-		std::vector<table*> open_inline_tables;
-		std::vector<array*> table_arrays;
-		parse_key_buffer key_buffer;
-		std::string string_buffer;
-		std::string recording_buffer; // for diagnostics
-		bool recording = false, recording_whitespace = true;
-		std::string_view current_scope;
-		size_t nested_values = {};
-#if !TOML_EXCEPTIONS
-		mutable optional<parse_error> err;
-#endif
-
-		TOML_NODISCARD
-		source_position current_position(source_index fallback_offset = 0) const noexcept
-		{
-			if (!is_eof())
-				return cp->position;
-			return { prev_pos.line, static_cast<source_index>(prev_pos.column + fallback_offset) };
-		}
-
-		template <typename... T>
-		TOML_RETURNS_BY_THROWING
-		TOML_NEVER_INLINE
-		void set_error_at(source_position pos, const T&... reason) const
-		{
-			static_assert(sizeof...(T) > 0);
-			return_if_error();
-
-			error_builder builder{ current_scope };
-			(builder.append(reason), ...);
-
-			parse_error_break();
-
-#if TOML_EXCEPTIONS
-			builder.finish(pos, reader.source_path());
-#else
-			err.emplace(builder.finish(pos, reader.source_path()));
-#endif
-		}
-
-		template <typename... T>
-		TOML_RETURNS_BY_THROWING
-		void set_error(const T&... reason) const
-		{
-			set_error_at(current_position(1), reason...);
-		}
-
-		void go_back(size_t count = 1) noexcept
-		{
-			return_if_error();
-			TOML_ASSERT_ASSUME(count);
-
-			cp		 = reader.step_back(count);
-			prev_pos = cp->position;
-		}
-
-		void advance()
-		{
-			return_if_error();
-			assert_not_eof();
-
-			prev_pos = cp->position;
-			cp		 = reader.read_next();
-
-#if !TOML_EXCEPTIONS
-			if (reader.error())
-			{
-				err = std::move(reader.error());
-				return;
-			}
-#endif
-
-			if (recording && !is_eof())
-			{
-				if (recording_whitespace || !is_whitespace(*cp))
-					recording_buffer.append(cp->bytes, cp->count);
-			}
-		}
-
-		void start_recording(bool include_current = true) noexcept
-		{
-			return_if_error();
-
-			recording			 = true;
-			recording_whitespace = true;
-			recording_buffer.clear();
-			if (include_current && !is_eof())
-				recording_buffer.append(cp->bytes, cp->count);
-		}
-
-		void stop_recording(size_t pop_bytes = 0) noexcept
-		{
-			return_if_error();
-
-			recording = false;
-			if (pop_bytes)
-			{
-				if (pop_bytes >= recording_buffer.length())
-					recording_buffer.clear();
-				else if (pop_bytes == 1u)
-					recording_buffer.pop_back();
-				else
-					recording_buffer.erase(recording_buffer.begin()
-											   + static_cast<ptrdiff_t>(recording_buffer.length() - pop_bytes),
-										   recording_buffer.end());
-			}
-		}
-
-		bool consume_leading_whitespace()
-		{
-			return_if_error_or_eof({});
-
-			bool consumed = false;
-			while (!is_eof() && is_horizontal_whitespace(*cp))
-			{
-				if TOML_UNLIKELY(!is_ascii_horizontal_whitespace(*cp))
-					set_error_and_return_default("expected space or tab, saw '"sv, escaped_codepoint{ *cp }, "'"sv);
-
-				consumed = true;
-				advance_and_return_if_error({});
-			}
-			return consumed;
-		}
-
-		bool consume_line_break()
-		{
-			return_if_error_or_eof({});
-
-			if TOML_UNLIKELY(is_match(*cp, U'\v', U'\f'))
-				set_error_and_return_default(
-					R"(vertical tabs '\v' and form-feeds '\f' are not legal line breaks in TOML)"sv);
-
-			if (*cp == U'\r')
-			{
-				advance_and_return_if_error({}); // skip \r
-
-				if TOML_UNLIKELY(is_eof())
-					set_error_and_return_default("expected '\\n' after '\\r', saw EOF"sv);
-
-				if TOML_UNLIKELY(*cp != U'\n')
-					set_error_and_return_default("expected '\\n' after '\\r', saw '"sv,
-												 escaped_codepoint{ *cp },
-												 "'"sv);
-			}
-			else if (*cp != U'\n')
-				return false;
-
-			advance_and_return_if_error({}); // skip \n
-			return true;
-		}
-
-		bool consume_rest_of_line()
-		{
-			return_if_error_or_eof({});
-
-			do
-			{
-				if (is_ascii_vertical_whitespace(*cp))
-					return consume_line_break();
-				else
-					advance();
-				return_if_error({});
-			}
-			while (!is_eof());
-
-			return true;
-		}
-
-		bool consume_comment()
-		{
-			return_if_error_or_eof({});
-
-			if (*cp != U'#')
-				return false;
-
-			push_parse_scope("comment"sv);
-
-			advance_and_return_if_error({}); // skip the '#'
-
-			while (!is_eof())
-			{
-				if (consume_line_break())
-					return true;
-				return_if_error({});
-
-#if TOML_LANG_AT_LEAST(1, 0, 0)
-
-				// toml/issues/567 (disallow non-TAB control characters in comments)
-				if TOML_UNLIKELY(is_nontab_control_character(*cp))
-					set_error_and_return_default(
-						"control characters other than TAB (U+0009) are explicitly prohibited in comments"sv);
-
-				// toml/pull/720 (disallow surrogates in comments)
-				else if TOML_UNLIKELY(is_unicode_surrogate(*cp))
-					set_error_and_return_default(
-						"unicode surrogates (U+D800 to U+DFFF) are explicitly prohibited in comments"sv);
-#endif
-
-				advance_and_return_if_error({});
-			}
-
-			return true;
-		}
-
-		TOML_NODISCARD
-		bool consume_expected_sequence(std::u32string_view seq)
-		{
-			return_if_error({});
-			TOML_ASSERT(!seq.empty());
-
-			for (auto c : seq)
-			{
-				set_error_and_return_if_eof({});
-				if (*cp != c)
-					return false;
-				advance_and_return_if_error({});
-			}
-			return true;
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		bool consume_digit_sequence(T* digits, size_t len)
-		{
-			return_if_error({});
-			TOML_ASSERT_ASSUME(digits);
-			TOML_ASSERT_ASSUME(len);
-
-			for (size_t i = 0; i < len; i++)
-			{
-				set_error_and_return_if_eof({});
-				if (!is_decimal_digit(*cp))
-					return false;
-
-				digits[i] = static_cast<T>(*cp - U'0');
-				advance_and_return_if_error({});
-			}
-			return true;
-		}
-
-		template <typename T>
-		TOML_NODISCARD
-		size_t consume_variable_length_digit_sequence(T* buffer, size_t max_len)
-		{
-			return_if_error({});
-			TOML_ASSERT_ASSUME(buffer);
-			TOML_ASSERT_ASSUME(max_len);
-
-			size_t i = {};
-			for (; i < max_len; i++)
-			{
-				if (is_eof() || !is_decimal_digit(*cp))
-					break;
-
-				buffer[i] = static_cast<T>(*cp - U'0');
-				advance_and_return_if_error({});
-			}
-			return i;
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		std::string_view parse_basic_string(bool multi_line)
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(*cp == U'"');
-			push_parse_scope("string"sv);
-
-			// skip the '"'
-			advance_and_return_if_error_or_eof({});
-
-			// multi-line strings ignore a single line ending right at the beginning
-			if (multi_line)
-			{
-				consume_line_break();
-				return_if_error({});
-				set_error_and_return_if_eof({});
-			}
-
-			auto& str = string_buffer;
-			str.clear();
-			bool escaped			 = false;
-			bool skipping_whitespace = false;
-			do
-			{
-				if (escaped)
-				{
-					escaped = false;
-
-					// handle 'line ending slashes' in multi-line mode
-					if (multi_line && is_whitespace(*cp))
-					{
-						consume_leading_whitespace();
-
-						if TOML_UNLIKELY(!consume_line_break())
-							set_error_and_return_default(
-								"line-ending backslashes must be the last non-whitespace character on the line"sv);
-
-						skipping_whitespace = true;
-						return_if_error({});
-						continue;
-					}
-
-					bool skip_escaped_codepoint = true;
-					assert_not_eof();
-					switch (const auto escaped_codepoint = *cp)
-					{
-						// 'regular' escape codes
-						case U'b': str += '\b'; break;
-						case U'f': str += '\f'; break;
-						case U'n': str += '\n'; break;
-						case U'r': str += '\r'; break;
-						case U't': str += '\t'; break;
-						case U'"': str += '"'; break;
-						case U'\\': str += '\\'; break;
-
-#if TOML_LANG_UNRELEASED // toml/pull/790 (\e shorthand for \x1B)
-						case U'e': str += '\x1B'; break;
-#else
-						case U'e':
-							set_error_and_return_default(
-								"escape sequence '\\e' is not supported in TOML 1.0.0 and earlier"sv);
-#endif
-
-#if TOML_LANG_UNRELEASED // toml/pull/796 (\xHH unicode scalar sequences)
-						case U'x': [[fallthrough]];
-#else
-						case U'x':
-							set_error_and_return_default(
-								"escape sequence '\\x' is not supported in TOML 1.0.0 and earlier"sv);
-#endif
-
-						// unicode scalar sequences
-						case U'u': [[fallthrough]];
-						case U'U':
-						{
-							push_parse_scope("unicode scalar sequence"sv);
-							advance_and_return_if_error_or_eof({});
-							skip_escaped_codepoint = false;
-
-							uint32_t place_value =
-								escaped_codepoint == U'U' ? 0x10000000u : (escaped_codepoint == U'u' ? 0x1000u : 0x10u);
-							uint32_t sequence_value{};
-							while (place_value)
-							{
-								set_error_and_return_if_eof({});
-
-								if TOML_UNLIKELY(!is_hexadecimal_digit(*cp))
-									set_error_and_return_default("expected hex digit, saw '"sv, to_sv(*cp), "'"sv);
-
-								sequence_value += place_value * hex_to_dec(*cp);
-								place_value /= 16u;
-								advance_and_return_if_error({});
-							}
-
-							if TOML_UNLIKELY(is_unicode_surrogate(sequence_value))
-								set_error_and_return_default(
-									"unicode surrogates (U+D800 - U+DFFF) are explicitly prohibited"sv);
-							else if TOML_UNLIKELY(sequence_value > 0x10FFFFu)
-								set_error_and_return_default("values greater than U+10FFFF are invalid"sv);
-
-							if (sequence_value < 0x80)
-							{
-								str += static_cast<char>(sequence_value);
-							}
-							else if (sequence_value < 0x800u)
-							{
-								str += static_cast<char>((sequence_value >> 6) | 0xC0u);
-								str += static_cast<char>((sequence_value & 0x3Fu) | 0x80u);
-							}
-							else if (sequence_value < 0x10000u)
-							{
-								str += static_cast<char>((sequence_value >> 12) | 0xE0u);
-								str += static_cast<char>(((sequence_value >> 6) & 0x3Fu) | 0x80u);
-								str += static_cast<char>((sequence_value & 0x3Fu) | 0x80u);
-							}
-							else if (sequence_value < 0x110000u)
-							{
-								str += static_cast<char>((sequence_value >> 18) | 0xF0u);
-								str += static_cast<char>(((sequence_value >> 12) & 0x3Fu) | 0x80u);
-								str += static_cast<char>(((sequence_value >> 6) & 0x3Fu) | 0x80u);
-								str += static_cast<char>((sequence_value & 0x3Fu) | 0x80u);
-							}
-							break;
-						}
-
-							// ???
-							TOML_UNLIKELY_CASE
-						default: set_error_and_return_default("unknown escape sequence '\\"sv, to_sv(*cp), "'"sv);
-					}
-
-					if (skip_escaped_codepoint)
-						advance_and_return_if_error_or_eof({});
-				}
-				else
-				{
-					// handle closing delimiters
-					if (*cp == U'"')
-					{
-						if (multi_line)
-						{
-							size_t lookaheads			  = {};
-							size_t consecutive_delimiters = 1;
-							do
-							{
-								advance_and_return_if_error({});
-								lookaheads++;
-								if (!is_eof() && *cp == U'"')
-									consecutive_delimiters++;
-								else
-									break;
-							}
-							while (lookaheads < 4u);
-
-							switch (consecutive_delimiters)
-							{
-								// """ " (one quote somewhere in a ML string)
-								case 1:
-									str += '"';
-									skipping_whitespace = false;
-									continue;
-
-								// """ "" (two quotes somewhere in a ML string)
-								case 2:
-									str.append("\"\""sv);
-									skipping_whitespace = false;
-									continue;
-
-								// """ """ (the end of the string)
-								case 3: return str;
-
-								// """ """" (one at the end of the string)
-								case 4: str += '"'; return str;
-
-								// """ """"" (two quotes at the end of the string)
-								case 5:
-									str.append("\"\""sv);
-									advance_and_return_if_error({}); // skip the last '"'
-									return str;
-
-								default: TOML_UNREACHABLE;
-							}
-						}
-						else
-						{
-							advance_and_return_if_error({}); // skip the closing delimiter
-							return str;
-						}
-					}
-
-					// handle escapes
-					else if (*cp == U'\\')
-					{
-						advance_and_return_if_error_or_eof({}); // skip the '\'
-						skipping_whitespace = false;
-						escaped				= true;
-						continue;
-					}
-
-					// handle line endings in multi-line mode
-					if (multi_line && is_ascii_vertical_whitespace(*cp))
-					{
-						consume_line_break();
-						return_if_error({});
-						if (!skipping_whitespace)
-							str += '\n';
-						continue;
-					}
-
-					// handle control characters
-					if TOML_UNLIKELY(is_nontab_control_character(*cp))
-						set_error_and_return_default(
-							"unescaped control characters other than TAB (U+0009) are explicitly prohibited"sv);
-
-#if TOML_LANG_AT_LEAST(1, 0, 0)
-
-					// handle surrogates in strings
-					if TOML_UNLIKELY(is_unicode_surrogate(*cp))
-						set_error_and_return_default(
-							"unescaped unicode surrogates (U+D800 to U+DFFF) are explicitly prohibited"sv);
-#endif
-
-					if (multi_line)
-					{
-						if (!skipping_whitespace || !is_horizontal_whitespace(*cp))
-						{
-							skipping_whitespace = false;
-							str.append(cp->bytes, cp->count);
-						}
-					}
-					else
-						str.append(cp->bytes, cp->count);
-
-					advance_and_return_if_error({});
-				}
-			}
-			while (!is_eof());
-
-			set_error_and_return_default("encountered end-of-file"sv);
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		std::string_view parse_literal_string(bool multi_line)
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(*cp == U'\'');
-			push_parse_scope("literal string"sv);
-
-			// skip the delimiter
-			advance_and_return_if_error_or_eof({});
-
-			// multi-line strings ignore a single line ending right at the beginning
-			if (multi_line)
-			{
-				consume_line_break();
-				return_if_error({});
-				set_error_and_return_if_eof({});
-			}
-
-			auto& str = string_buffer;
-			str.clear();
-			do
-			{
-				return_if_error({});
-
-				// handle closing delimiters
-				if (*cp == U'\'')
-				{
-					if (multi_line)
-					{
-						size_t lookaheads			  = {};
-						size_t consecutive_delimiters = 1;
-						do
-						{
-							advance_and_return_if_error({});
-							lookaheads++;
-							if (!is_eof() && *cp == U'\'')
-								consecutive_delimiters++;
-							else
-								break;
-						}
-						while (lookaheads < 4u);
-
-						switch (consecutive_delimiters)
-						{
-							// ''' ' (one quote somewhere in a ML string)
-							case 1: str += '\''; continue;
-
-							// ''' '' (two quotes somewhere in a ML string)
-							case 2: str.append("''"sv); continue;
-
-							// ''' ''' (the end of the string)
-							case 3: return str;
-
-							// ''' '''' (one at the end of the string)
-							case 4: str += '\''; return str;
-
-							// ''' ''''' (two quotes at the end of the string)
-							case 5:
-								str.append("''"sv);
-								advance_and_return_if_error({}); // skip the last '
-								return str;
-
-							default: TOML_UNREACHABLE;
-						}
-					}
-					else
-					{
-						advance_and_return_if_error({}); // skip the closing delimiter
-						return str;
-					}
-				}
-
-				// handle line endings in multi-line mode
-				if (multi_line && is_ascii_vertical_whitespace(*cp))
-				{
-					consume_line_break();
-					return_if_error({});
-					str += '\n';
-					continue;
-				}
-
-				// handle control characters
-				if TOML_UNLIKELY(is_nontab_control_character(*cp))
-					set_error_and_return_default(
-						"control characters other than TAB (U+0009) are explicitly prohibited"sv);
-
-#if TOML_LANG_AT_LEAST(1, 0, 0)
-
-				// handle surrogates in strings
-				if TOML_UNLIKELY(is_unicode_surrogate(*cp))
-					set_error_and_return_default("unicode surrogates (U+D800 - U+DFFF) are explicitly prohibited"sv);
-#endif
-
-				str.append(cp->bytes, cp->count);
-				advance_and_return_if_error({});
-			}
-			while (!is_eof());
-
-			set_error_and_return_default("encountered end-of-file"sv);
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		parsed_string parse_string()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_string_delimiter(*cp));
-			push_parse_scope("string"sv);
-
-			// get the first three characters to determine the string type
-			const auto first = cp->value;
-			advance_and_return_if_error_or_eof({});
-			const auto second = cp->value;
-			advance_and_return_if_error({});
-			const auto third = cp ? cp->value : U'\0';
-
-			// if we were eof at the third character then first and second need to be
-			// the same string character (otherwise it's an unterminated string)
-			if (is_eof())
-			{
-				if (second == first)
-					return {};
-
-				set_error_and_return_default("encountered end-of-file"sv);
-			}
-
-			// if the first three characters are all the same string delimiter then
-			// it's a multi-line string.
-			else if (first == second && first == third)
-			{
-				return { first == U'\'' ? parse_literal_string(true) : parse_basic_string(true), true };
-			}
-
-			// otherwise it's just a regular string.
-			else
-			{
-				// step back two characters so that the current
-				// character is the string delimiter
-				go_back(2u);
-
-				return { first == U'\'' ? parse_literal_string(false) : parse_basic_string(false), false };
-			}
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		std::string_view parse_bare_key_segment()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_bare_key_character(*cp));
-
-			string_buffer.clear();
-
-			while (!is_eof())
-			{
-				if (!is_bare_key_character(*cp))
-					break;
-
-				string_buffer.append(cp->bytes, cp->count);
-				advance_and_return_if_error({});
-			}
-
-			return string_buffer;
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		bool parse_boolean()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_match(*cp, U't', U'f', U'T', U'F'));
-			push_parse_scope("boolean"sv);
-
-			start_recording(true);
-			auto result = is_match(*cp, U't', U'T');
-			if (!consume_expected_sequence(result ? U"true"sv : U"false"sv))
-				set_error_and_return_default("expected '"sv,
-											 to_sv(result),
-											 "', saw '"sv,
-											 to_sv(recording_buffer),
-											 "'"sv);
-			stop_recording();
-
-			if (cp && !is_value_terminator(*cp))
-				set_error_and_return_default("expected value-terminator, saw '"sv, to_sv(*cp), "'"sv);
-
-			return result;
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		double parse_inf_or_nan()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_match(*cp, U'i', U'n', U'I', U'N', U'+', U'-'));
-			push_parse_scope("floating-point"sv);
-
-			start_recording(true);
-			const bool negative = *cp == U'-';
-			if (negative || *cp == U'+')
-				advance_and_return_if_error_or_eof({});
-
-			const bool inf = is_match(*cp, U'i', U'I');
-			if (!consume_expected_sequence(inf ? U"inf"sv : U"nan"sv))
-				set_error_and_return_default("expected '"sv,
-											 inf ? "inf"sv : "nan"sv,
-											 "', saw '"sv,
-											 to_sv(recording_buffer),
-											 "'"sv);
-			stop_recording();
-
-			if (cp && !is_value_terminator(*cp))
-				set_error_and_return_default("expected value-terminator, saw '"sv, to_sv(*cp), "'"sv);
-
-			return inf ? (negative ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity())
-					   : std::numeric_limits<double>::quiet_NaN();
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		double parse_float()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_match(*cp, U'+', U'-', U'.') || is_decimal_digit(*cp));
-			push_parse_scope("floating-point"sv);
-
-			// sign
-			const int sign = *cp == U'-' ? -1 : 1;
-			if (is_match(*cp, U'+', U'-'))
-				advance_and_return_if_error_or_eof({});
-
-			// consume value chars
-			char chars[utf8_buffered_reader::max_history_length];
-			size_t length			   = {};
-			const utf8_codepoint* prev = {};
-			bool seen_decimal = false, seen_exponent = false;
-			char first_integer_part = '\0';
-			while (!is_eof() && !is_value_terminator(*cp))
-			{
-				if (*cp == U'_')
-				{
-					if (!prev || !is_decimal_digit(*prev))
-						set_error_and_return_default("underscores may only follow digits"sv);
-
-					prev = cp;
-					advance_and_return_if_error_or_eof({});
-					continue;
-				}
-				else if TOML_UNLIKELY(prev && *prev == U'_' && !is_decimal_digit(*cp))
-					set_error_and_return_default("underscores must be followed by digits"sv);
-				else if TOML_UNLIKELY(length == sizeof(chars))
-					set_error_and_return_default("exceeds length limit of "sv,
-												 sizeof(chars),
-												 " digits"sv,
-												 (seen_exponent ? ""sv : " (consider using exponent notation)"sv));
-				else if (*cp == U'.')
-				{
-					// .1
-					// -.1
-					// +.1 (no integer part)
-					if (!first_integer_part)
-						set_error_and_return_default("expected decimal digit, saw '.'"sv);
-
-					// 1.0e+.10 (exponent cannot have '.')
-					else if (seen_exponent)
-						set_error_and_return_default("expected exponent decimal digit or sign, saw '.'"sv);
-
-					// 1.0.e+.10
-					// 1..0
-					// (multiple '.')
-					else if (seen_decimal)
-						set_error_and_return_default("expected decimal digit or exponent, saw '.'"sv);
-
-					seen_decimal = true;
-				}
-				else if (is_match(*cp, U'e', U'E'))
-				{
-					if (prev && !is_decimal_digit(*prev))
-						set_error_and_return_default("expected decimal digit, saw '"sv, to_sv(*cp), "'"sv);
-
-					// 1.0ee+10 (multiple 'e')
-					else if (seen_exponent)
-						set_error_and_return_default("expected decimal digit, saw '"sv, to_sv(*cp), "'"sv);
-
-					seen_decimal  = true; // implied
-					seen_exponent = true;
-				}
-				else if (is_match(*cp, U'+', U'-'))
-				{
-					// 1.-0 (sign in mantissa)
-					if (!seen_exponent)
-						set_error_and_return_default("expected decimal digit or '.', saw '"sv, to_sv(*cp), "'"sv);
-
-					// 1.0e1-0 (misplaced exponent sign)
-					else if (!is_match(*prev, U'e', U'E'))
-						set_error_and_return_default("expected exponent digit, saw '"sv, to_sv(*cp), "'"sv);
-				}
-				else if (is_decimal_digit(*cp))
-				{
-					if (!seen_decimal)
-					{
-						if (!first_integer_part)
-							first_integer_part = static_cast<char>(cp->bytes[0]);
-						else if (first_integer_part == '0')
-							set_error_and_return_default("leading zeroes are prohibited"sv);
-					}
-				}
-				else
-					set_error_and_return_default("expected decimal digit, saw '"sv, to_sv(*cp), "'"sv);
-
-				chars[length++] = static_cast<char>(cp->bytes[0]);
-				prev			= cp;
-				advance_and_return_if_error({});
-			}
-
-			// sanity-check ending state
-			if (prev)
-			{
-				if (*prev == U'_')
-				{
-					set_error_and_return_if_eof({});
-					set_error_and_return_default("underscores must be followed by digits"sv);
-				}
-				else if (is_match(*prev, U'e', U'E', U'+', U'-', U'.'))
-				{
-					set_error_and_return_if_eof({});
-					set_error_and_return_default("expected decimal digit, saw '"sv, to_sv(*cp), "'"sv);
-				}
-			}
-
-			// convert to double
-			double result;
-#if TOML_FLOAT_CHARCONV
-			{
-				auto fc_result = std::from_chars(chars, chars + length, result);
-				switch (fc_result.ec)
-				{
-					TOML_LIKELY_CASE
-					case std::errc{}: // ok
-						return result * sign;
-
-					case std::errc::invalid_argument:
-						set_error_and_return_default("'"sv,
-													 std::string_view{ chars, length },
-													 "' could not be interpreted as a value"sv);
-						break;
-
-					case std::errc::result_out_of_range:
-						set_error_and_return_default("'"sv,
-													 std::string_view{ chars, length },
-													 "' is not representable in 64 bits"sv);
-						break;
-
-					default: //??
-						set_error_and_return_default("an unspecified error occurred while trying to interpret '"sv,
-													 std::string_view{ chars, length },
-													 "' as a value"sv);
-				}
-			}
-#else
-			{
-				std::stringstream ss;
-				ss.imbue(std::locale::classic());
-				ss.write(chars, static_cast<std::streamsize>(length));
-				if ((ss >> result))
-					return result * sign;
-				else
-					set_error_and_return_default("'"sv,
-												 std::string_view{ chars, length },
-												 "' could not be interpreted as a value"sv);
-			}
-#endif
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		double parse_hex_float()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_match(*cp, U'0', U'+', U'-'));
-			push_parse_scope("hexadecimal floating-point"sv);
-
-#if TOML_LANG_UNRELEASED // toml/issues/562 (hexfloats)
-
-			// sign
-			const int sign = *cp == U'-' ? -1 : 1;
-			if (is_match(*cp, U'+', U'-'))
-				advance_and_return_if_error_or_eof({});
-
-			// '0'
-			if (*cp != U'0')
-				set_error_and_return_default(" expected '0', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// 'x' or 'X'
-			if (!is_match(*cp, U'x', U'X'))
-				set_error_and_return_default("expected 'x' or 'X', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// <HEX DIGITS> ([.]<HEX DIGITS>)? [pP] [+-]? <DEC DIGITS>
-
-			// consume value fragments
-			struct fragment
-			{
-				char chars[24];
-				size_t length;
-				double value;
-			};
-			fragment fragments[] = {
-				{}, // mantissa, whole part
-				{}, // mantissa, fractional part
-				{}	// exponent
-			};
-			fragment* current_fragment = fragments;
-			const utf8_codepoint* prev = {};
-			int exponent_sign		   = 1;
-			while (!is_eof() && !is_value_terminator(*cp))
-			{
-				if (*cp == U'_')
-				{
-					if (!prev || !is_hexadecimal_digit(*prev))
-						set_error_and_return_default("underscores may only follow digits"sv);
-
-					prev = cp;
-					advance_and_return_if_error_or_eof({});
-					continue;
-				}
-				else if (prev && *prev == U'_' && !is_hexadecimal_digit(*cp))
-					set_error_and_return_default("underscores must be followed by digits"sv);
-				else if (*cp == U'.')
-				{
-					// 0x10.0p-.0 (exponent cannot have '.')
-					if (current_fragment == fragments + 2)
-						set_error_and_return_default("expected exponent digit or sign, saw '.'"sv);
-
-					// 0x10.0.p-0 (multiple '.')
-					else if (current_fragment == fragments + 1)
-						set_error_and_return_default("expected hexadecimal digit or exponent, saw '.'"sv);
-
-					else
-						current_fragment++;
-				}
-				else if (is_match(*cp, U'p', U'P'))
-				{
-					// 0x10.0pp-0 (multiple 'p')
-					if (current_fragment == fragments + 2)
-						set_error_and_return_default("expected exponent digit or sign, saw '"sv, to_sv(*cp), "'"sv);
-
-					// 0x.p-0 (mantissa is just '.')
-					else if (fragments[0].length == 0u && fragments[1].length == 0u)
-						set_error_and_return_default("expected hexadecimal digit, saw '"sv, to_sv(*cp), "'"sv);
-
-					else
-						current_fragment = fragments + 2;
-				}
-				else if (is_match(*cp, U'+', U'-'))
-				{
-					// 0x-10.0p-0 (sign in mantissa)
-					if (current_fragment != fragments + 2)
-						set_error_and_return_default("expected hexadecimal digit or '.', saw '"sv, to_sv(*cp), "'"sv);
-
-					// 0x10.0p0- (misplaced exponent sign)
-					else if (!is_match(*prev, U'p', U'P'))
-						set_error_and_return_default("expected exponent digit, saw '"sv, to_sv(*cp), "'"sv);
-
-					else
-						exponent_sign = *cp == U'-' ? -1 : 1;
-				}
-				else if (current_fragment < fragments + 2 && !is_hexadecimal_digit(*cp))
-					set_error_and_return_default("expected hexadecimal digit or '.', saw '"sv, to_sv(*cp), "'"sv);
-				else if (current_fragment == fragments + 2 && !is_decimal_digit(*cp))
-					set_error_and_return_default("expected exponent digit or sign, saw '"sv, to_sv(*cp), "'"sv);
-				else if (current_fragment->length == sizeof(fragment::chars))
-					set_error_and_return_default("fragment exceeeds maximum length of "sv,
-												 sizeof(fragment::chars),
-												 " characters"sv);
-				else
-					current_fragment->chars[current_fragment->length++] = static_cast<char>(cp->bytes[0]);
-
-				prev = cp;
-				advance_and_return_if_error({});
-			}
-
-			// sanity-check ending state
-			if (current_fragment != fragments + 2 || current_fragment->length == 0u)
-			{
-				set_error_and_return_if_eof({});
-				set_error_and_return_default("missing exponent"sv);
-			}
-			else if (prev && *prev == U'_')
-			{
-				set_error_and_return_if_eof({});
-				set_error_and_return_default("underscores must be followed by digits"sv);
-			}
-
-			// calculate values for the three fragments
-			for (int fragment_idx = 0; fragment_idx < 3; fragment_idx++)
-			{
-				auto& f				= fragments[fragment_idx];
-				const uint32_t base = fragment_idx == 2 ? 10u : 16u;
-
-				// left-trim zeroes
-				const char* c = f.chars;
-				size_t sig	  = {};
-				while (f.length && *c == '0')
-				{
-					f.length--;
-					c++;
-					sig++;
-				}
-				if (!f.length)
-					continue;
-
-				// calculate value
-				auto place = 1u;
-				for (size_t i = 0; i < f.length - 1u; i++)
-					place *= base;
-				uint32_t val{};
-				while (place)
-				{
-					if (base == 16)
-						val += place * hex_to_dec(*c);
-					else
-						val += place * static_cast<uint32_t>(*c - '0');
-					if (fragment_idx == 1)
-						sig++;
-					c++;
-					place /= base;
-				}
-				f.value = static_cast<double>(val);
-
-				// shift the fractional part
-				if (fragment_idx == 1)
-				{
-					while (sig--)
-						f.value /= base;
-				}
-			}
-
-			return (fragments[0].value + fragments[1].value) * pow(2.0, fragments[2].value * exponent_sign) * sign;
-
-#else // !TOML_LANG_UNRELEASED
-
-			set_error_and_return_default("hexadecimal floating-point values are not supported "
-										 "in TOML 1.0.0 and earlier"sv);
-
-#endif // !TOML_LANG_UNRELEASED
-		}
-
-		template <uint64_t base>
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		int64_t parse_integer()
-		{
-			return_if_error({});
-			assert_not_eof();
-			using traits = parse_integer_traits<base>;
-			push_parse_scope(traits::scope_qualifier);
-
-			[[maybe_unused]] int64_t sign = 1;
-			if constexpr (traits::is_signed)
-			{
-				sign = *cp == U'-' ? -1 : 1;
-				if (is_match(*cp, U'+', U'-'))
-					advance_and_return_if_error_or_eof({});
-			}
-
-			if constexpr (base == 10)
-			{
-				if (!traits::is_digit(*cp))
-					set_error_and_return_default("expected expected digit or sign, saw '"sv, to_sv(*cp), "'"sv);
-			}
-			else
-			{
-				// '0'
-				if (*cp != U'0')
-					set_error_and_return_default("expected '0', saw '"sv, to_sv(*cp), "'"sv);
-				advance_and_return_if_error_or_eof({});
-
-				// 'b', 'o', 'x'
-				if (*cp != traits::prefix_codepoint)
-					set_error_and_return_default("expected '"sv, traits::prefix, "', saw '"sv, to_sv(*cp), "'"sv);
-				advance_and_return_if_error_or_eof({});
-
-				if (!traits::is_digit(*cp))
-					set_error_and_return_default("expected digit, saw '"sv, to_sv(*cp), "'"sv);
-			}
-
-			// consume digits
-			char digits[utf8_buffered_reader::max_history_length];
-			size_t length			   = {};
-			const utf8_codepoint* prev = {};
-			while (!is_eof() && !is_value_terminator(*cp))
-			{
-				if (*cp == U'_')
-				{
-					if (!prev || !traits::is_digit(*prev))
-						set_error_and_return_default("underscores may only follow digits"sv);
-
-					prev = cp;
-					advance_and_return_if_error_or_eof({});
-					continue;
-				}
-				else if TOML_UNLIKELY(prev && *prev == U'_' && !traits::is_digit(*cp))
-					set_error_and_return_default("underscores must be followed by digits"sv);
-				else if TOML_UNLIKELY(!traits::is_digit(*cp))
-					set_error_and_return_default("expected digit, saw '"sv, to_sv(*cp), "'"sv);
-				else if TOML_UNLIKELY(length == sizeof(digits))
-					set_error_and_return_default("exceeds length limit of "sv, sizeof(digits), " digits"sv);
-				else
-					digits[length++] = static_cast<char>(cp->bytes[0]);
-
-				prev = cp;
-				advance_and_return_if_error({});
-			}
-
-			// sanity check ending state
-			if (prev && *prev == U'_')
-			{
-				set_error_and_return_if_eof({});
-				set_error_and_return_default("underscores must be followed by digits"sv);
-			}
-
-			// single digits can be converted trivially
-			if (length == 1u)
-			{
-				int64_t result;
-
-				if constexpr (base == 16)
-					result = static_cast<int64_t>(hex_to_dec(digits[0]));
-				else
-					result = static_cast<int64_t>(digits[0] - '0');
-
-				if constexpr (traits::is_signed)
-					result *= sign;
-
-				return result;
-			}
-
-			// bin, oct and hex allow leading zeroes so trim them first
-			const char* end = digits + length;
-			const char* msd = digits;
-			if constexpr (base != 10)
-			{
-				while (msd < end && *msd == '0')
-					msd++;
-				if (msd == end)
-					return 0ll;
-			}
-
-			// decimal integers do not allow leading zeroes
-			else
-			{
-				if TOML_UNLIKELY(digits[0] == '0')
-					set_error_and_return_default("leading zeroes are prohibited"sv);
-			}
-
-			// range check
-			if TOML_UNLIKELY(static_cast<size_t>(end - msd) > traits::max_digits)
-				set_error_and_return_default("'"sv,
-											 traits::full_prefix,
-											 std::string_view{ digits, length },
-											 "' is not representable in 64 bits"sv);
-
-			// do the thing
-			{
-				uint64_t result = {};
-				{
-					uint64_t power = 1;
-					while (--end >= msd)
-					{
-						if constexpr (base == 16)
-							result += power * hex_to_dec(*end);
-						else
-							result += power * static_cast<uint64_t>(*end - '0');
-
-						power *= base;
-					}
-				}
-
-				// range check
-				if TOML_UNLIKELY(result > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()) + (sign < 0 ? 1ull : 0ull))
-					set_error_and_return_default("'"sv,
-												 traits::full_prefix,
-												 std::string_view{ digits, length },
-												 "' is not representable in 64 bits"sv);
-
-				if constexpr (traits::is_signed)
-					return static_cast<int64_t>(result) * sign;
-				else
-					return static_cast<int64_t>(result);
-			}
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		date parse_date(bool part_of_datetime = false)
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_decimal_digit(*cp));
-			push_parse_scope("date"sv);
-
-			// "YYYY"
-			uint32_t digits[4];
-			if (!consume_digit_sequence(digits, 4u))
-				set_error_and_return_default("expected 4-digit year, saw '"sv, to_sv(cp), "'"sv);
-			const auto year			= digits[3] + digits[2] * 10u + digits[1] * 100u + digits[0] * 1000u;
-			const auto is_leap_year = (year % 4u == 0u) && ((year % 100u != 0u) || (year % 400u == 0u));
-			set_error_and_return_if_eof({});
-
-			// '-'
-			if (*cp != U'-')
-				set_error_and_return_default("expected '-', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "MM"
-			if (!consume_digit_sequence(digits, 2u))
-				set_error_and_return_default("expected 2-digit month, saw '"sv, to_sv(cp), "'"sv);
-			const auto month = digits[1] + digits[0] * 10u;
-			if (month == 0u || month > 12u)
-				set_error_and_return_default("expected month between 1 and 12 (inclusive), saw "sv, month);
-			const auto max_days_in_month = month == 2u
-											 ? (is_leap_year ? 29u : 28u)
-											 : (month == 4u || month == 6u || month == 9u || month == 11u ? 30u : 31u);
-			set_error_and_return_if_eof({});
-
-			// '-'
-			if (*cp != U'-')
-				set_error_and_return_default("expected '-', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "DD"
-			if (!consume_digit_sequence(digits, 2u))
-				set_error_and_return_default("expected 2-digit day, saw '"sv, to_sv(cp), "'"sv);
-			const auto day = digits[1] + digits[0] * 10u;
-			if (day == 0u || day > max_days_in_month)
-				set_error_and_return_default("expected day between 1 and "sv,
-											 max_days_in_month,
-											 " (inclusive), saw "sv,
-											 day);
-
-			if (!part_of_datetime && !is_eof() && !is_value_terminator(*cp))
-				set_error_and_return_default("expected value-terminator, saw '"sv, to_sv(*cp), "'"sv);
-
-			return { year, month, day };
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		time parse_time(bool part_of_datetime = false)
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_decimal_digit(*cp));
-			push_parse_scope("time"sv);
-
-			static constexpr size_t max_digits = 64; // far more than necessary but needed to allow fractional
-													 // millisecond truncation per the spec
-			uint32_t digits[max_digits];
-
-			// "HH"
-			if (!consume_digit_sequence(digits, 2u))
-				set_error_and_return_default("expected 2-digit hour, saw '"sv, to_sv(cp), "'"sv);
-			const auto hour = digits[1] + digits[0] * 10u;
-			if (hour > 23u)
-				set_error_and_return_default("expected hour between 0 to 59 (inclusive), saw "sv, hour);
-			set_error_and_return_if_eof({});
-
-			// ':'
-			if (*cp != U':')
-				set_error_and_return_default("expected ':', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "MM"
-			if (!consume_digit_sequence(digits, 2u))
-				set_error_and_return_default("expected 2-digit minute, saw '"sv, to_sv(cp), "'"sv);
-			const auto minute = digits[1] + digits[0] * 10u;
-			if (minute > 59u)
-				set_error_and_return_default("expected minute between 0 and 59 (inclusive), saw "sv, minute);
-			auto time = toml::time{ hour, minute };
-
-			// ':'
-			if constexpr (TOML_LANG_UNRELEASED) // toml/issues/671 (allow omission of seconds)
-			{
-				if (is_eof() || is_value_terminator(*cp) || (part_of_datetime && is_match(*cp, U'+', U'-', U'Z', U'z')))
-					return time;
-			}
-			else
-				set_error_and_return_if_eof({});
-			if (*cp != U':')
-				set_error_and_return_default("expected ':', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "SS"
-			if (!consume_digit_sequence(digits, 2u))
-				set_error_and_return_default("expected 2-digit second, saw '"sv, to_sv(cp), "'"sv);
-			const auto second = digits[1] + digits[0] * 10u;
-			if (second > 59u)
-				set_error_and_return_default("expected second between 0 and 59 (inclusive), saw "sv, second);
-			time.second = static_cast<decltype(time.second)>(second);
-
-			// '.' (early-exiting is allowed; fractional is optional)
-			if (is_eof() || is_value_terminator(*cp) || (part_of_datetime && is_match(*cp, U'+', U'-', U'Z', U'z')))
-				return time;
-			if (*cp != U'.')
-				set_error_and_return_default("expected '.', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "FFFFFFFFF"
-			size_t digit_count = consume_variable_length_digit_sequence(digits, max_digits);
-			if (!digit_count)
-			{
-				set_error_and_return_if_eof({});
-				set_error_and_return_default("expected fractional digits, saw '"sv, to_sv(*cp), "'"sv);
-			}
-			else if (!is_eof())
-			{
-				if (digit_count == max_digits && is_decimal_digit(*cp))
-					set_error_and_return_default("fractional component exceeds maximum precision of "sv, max_digits);
-				else if (!part_of_datetime && !is_value_terminator(*cp))
-					set_error_and_return_default("expected value-terminator, saw '"sv, to_sv(*cp), "'"sv);
-			}
-			uint32_t value = 0u;
-			uint32_t place = 1u;
-			for (auto i = impl::min<size_t>(digit_count, 9u); i-- > 0u;)
-			{
-				value += digits[i] * place;
-				place *= 10u;
-			}
-			for (auto i = digit_count; i < 9u; i++) // implicit zeros
-				value *= 10u;
-			time.nanosecond = value;
-			return time;
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		date_time parse_date_time()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_decimal_digit(*cp));
-			push_parse_scope("date-time"sv);
-
-			// "YYYY-MM-DD"
-			auto date = parse_date(true);
-			set_error_and_return_if_eof({});
-
-			// ' ', 'T' or 't'
-			if (!is_match(*cp, U' ', U'T', U't'))
-				set_error_and_return_default("expected space, 'T' or 't', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// "HH:MM:SS.FFFFFFFFF"
-			auto time = parse_time(true);
-			return_if_error({});
-
-			// no offset
-			if (is_eof() || is_value_terminator(*cp))
-				return { date, time };
-
-			// zero offset ('Z' or 'z')
-			time_offset offset{};
-			if (is_match(*cp, U'Z', U'z'))
-				advance_and_return_if_error({});
-
-			// explicit offset ("+/-HH:MM")
-			else if (is_match(*cp, U'+', U'-'))
-			{
-				push_parse_scope("date-time offset"sv);
-
-				// sign
-				int sign = *cp == U'-' ? -1 : 1;
-				advance_and_return_if_error_or_eof({});
-
-				// "HH"
-				int digits[2];
-				if (!consume_digit_sequence(digits, 2u))
-					set_error_and_return_default("expected 2-digit hour, saw '"sv, to_sv(cp), "'"sv);
-				const auto hour = digits[1] + digits[0] * 10;
-				if (hour > 23)
-					set_error_and_return_default("expected hour between 0 and 23 (inclusive), saw "sv, hour);
-				set_error_and_return_if_eof({});
-
-				// ':'
-				if (*cp != U':')
-					set_error_and_return_default("expected ':', saw '"sv, to_sv(*cp), "'"sv);
-				advance_and_return_if_error_or_eof({});
-
-				// "MM"
-				if (!consume_digit_sequence(digits, 2u))
-					set_error_and_return_default("expected 2-digit minute, saw '"sv, to_sv(cp), "'"sv);
-				const auto minute = digits[1] + digits[0] * 10;
-				if (minute > 59)
-					set_error_and_return_default("expected minute between 0 and 59 (inclusive), saw "sv, minute);
-				offset.minutes = static_cast<decltype(offset.minutes)>((hour * 60 + minute) * sign);
-			}
-
-			if (!is_eof() && !is_value_terminator(*cp))
-				set_error_and_return_default("expected value-terminator, saw '"sv, to_sv(*cp), "'"sv);
-
-			return { date, time, offset };
-		}
-
-		TOML_NODISCARD
-		node_ptr parse_array();
-
-		TOML_NODISCARD
-		node_ptr parse_inline_table();
-
-		TOML_NODISCARD
-		node_ptr parse_value_known_prefixes()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(!is_control_character(*cp));
-			TOML_ASSERT_ASSUME(*cp != U'_');
-
-			switch (cp->value)
-			{
-				// arrays
-				case U'[': return parse_array();
-
-				// inline tables
-				case U'{': return parse_inline_table();
-
-				// floats beginning with '.'
-				case U'.': return node_ptr{ new value{ parse_float() } };
-
-				// strings
-				case U'"': [[fallthrough]];
-				case U'\'': return node_ptr{ new value{ parse_string().value } };
-
-				default:
-				{
-					const auto cp_upper = static_cast<uint_least32_t>(cp->value) & ~0x20u;
-
-					// bools
-					if (cp_upper == 70u || cp_upper == 84u) // F or T
-						return node_ptr{ new value{ parse_boolean() } };
-
-					// inf/nan
-					else if (cp_upper == 73u || cp_upper == 78u) // I or N
-						return node_ptr{ new value{ parse_inf_or_nan() } };
-
-					else
-						return nullptr;
-				}
-			}
-			TOML_UNREACHABLE;
-		}
-
-		TOML_NODISCARD
-		node_ptr parse_value()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(!is_value_terminator(*cp));
-			push_parse_scope("value"sv);
-
-			const depth_counter_scope depth_counter{ nested_values };
-			if TOML_UNLIKELY(nested_values > max_nested_values)
-				set_error_and_return_default("exceeded maximum nested value depth of "sv,
-											 max_nested_values,
-											 " (TOML_MAX_NESTED_VALUES)"sv);
-
-			// check if it begins with some control character
-			// (note that this will also fail for whitespace but we're assuming we've
-			// called consume_leading_whitespace() before calling parse_value())
-			if TOML_UNLIKELY(is_control_character(*cp))
-				set_error_and_return_default("unexpected control character"sv);
-
-			// underscores at the beginning
-			else if (*cp == U'_')
-				set_error_and_return_default("values may not begin with underscores"sv);
-
-			const auto begin_pos = cp->position;
-			node_ptr val;
-
-			do
-			{
-				TOML_ASSERT_ASSUME(!is_control_character(*cp));
-				TOML_ASSERT_ASSUME(*cp != U'_');
-
-				// detect the value type and parse accordingly,
-				// starting with value types that can be detected
-				// unambiguously from just one character.
-
-				val = parse_value_known_prefixes();
-				return_if_error({});
-				if (val)
-					break;
-
-				// value types from here down require more than one character to unambiguously identify
-				// so scan ahead and collect a set of value 'traits'.
-				enum TOML_CLOSED_FLAGS_ENUM value_traits : int
-				{
-					has_nothing	 = 0,
-					has_digits	 = 1,
-					has_b		 = 1 << 1, // as second char only (0b)
-					has_e		 = 1 << 2, // only float exponents
-					has_o		 = 1 << 3, // as second char only (0o)
-					has_p		 = 1 << 4, // only hexfloat exponents
-					has_t		 = 1 << 5,
-					has_x		 = 1 << 6, // as second or third char only (0x, -0x, +0x)
-					has_z		 = 1 << 7,
-					has_colon	 = 1 << 8,
-					has_plus	 = 1 << 9,
-					has_minus	 = 1 << 10,
-					has_dot		 = 1 << 11,
-					begins_sign	 = 1 << 12,
-					begins_digit = 1 << 13,
-					begins_zero	 = 1 << 14,
-					signs_msk  = has_plus | has_minus,
-					bdigit_msk = has_digits | begins_digit,
-					bzero_msk  = bdigit_msk | begins_zero,
-				};
-				value_traits traits	 = has_nothing;
-				const auto has_any	 = [&](auto t) noexcept { return (traits & t) != has_nothing; };
-				const auto has_none	 = [&](auto t) noexcept { return (traits & t) == has_nothing; };
-				const auto add_trait = [&](auto t) noexcept { traits = static_cast<value_traits>(traits | t); };
-
-				// examine the first character to get the 'begins with' traits
-				// (good fail-fast opportunity; all the remaining types begin with numeric digits or signs)
-				if (is_decimal_digit(*cp))
-				{
-					add_trait(begins_digit);
-					if (*cp == U'0')
-						add_trait(begins_zero);
-				}
-				else if (is_match(*cp, U'+', U'-'))
-					add_trait(begins_sign);
-				else
-					break;
-
-				// scan the rest of the value to determine the remaining traits
-				char32_t chars[utf8_buffered_reader::max_history_length];
-				size_t char_count = {}, advance_count = {};
-				bool eof_while_scanning = false;
-				const auto scan			= [&]() noexcept(!TOML_COMPILER_HAS_EXCEPTIONS)
-				{
-					if (is_eof())
-						return;
-					TOML_ASSERT_ASSUME(!is_value_terminator(*cp));
-
-					do
-					{
-						if (const auto c = **cp; c != U'_')
-						{
-							chars[char_count++] = c;
-
-							if (is_decimal_digit(c))
-								add_trait(has_digits);
-							else if (is_ascii_letter(c))
-							{
-								TOML_ASSERT_ASSUME((c >= U'a' && c <= U'z') || (c >= U'A' && c <= U'Z'));
-								switch (static_cast<char32_t>(c | 32u))
-								{
-									case U'b':
-										if (char_count == 2u && has_any(begins_zero))
-											add_trait(has_b);
-										break;
-
-									case U'e':
-										if (char_count > 1u
-											&& has_none(has_b | has_o | has_p | has_t | has_x | has_z | has_colon)
-											&& (has_none(has_plus | has_minus) || has_any(begins_sign)))
-											add_trait(has_e);
-										break;
-
-									case U'o':
-										if (char_count == 2u && has_any(begins_zero))
-											add_trait(has_o);
-										break;
-
-									case U'p':
-										if (has_any(has_x))
-											add_trait(has_p);
-										break;
-
-									case U'x':
-										if ((char_count == 2u && has_any(begins_zero))
-											|| (char_count == 3u && has_any(begins_sign) && chars[1] == U'0'))
-											add_trait(has_x);
-										break;
-
-									case U't': add_trait(has_t); break;
-									case U'z': add_trait(has_z); break;
-								}
-							}
-							else if (c <= U':')
-							{
-								TOML_ASSERT_ASSUME(c < U'0' || c > U'9');
-								switch (c)
-								{
-									case U'+': add_trait(has_plus); break;
-									case U'-': add_trait(has_minus); break;
-									case U'.': add_trait(has_dot); break;
-									case U':': add_trait(has_colon); break;
-								}
-							}
-						}
-
-						advance_and_return_if_error();
-						advance_count++;
-						eof_while_scanning = is_eof();
-					}
-					while (advance_count < (utf8_buffered_reader::max_history_length - 1u) && !is_eof()
-						   && !is_value_terminator(*cp));
-				};
-				scan();
-				return_if_error({});
-
-				// force further scanning if this could have been a date-time with a space instead of a T
-				if (char_count == 10u									 //
-					&& (traits | begins_zero) == (bzero_msk | has_minus) //
-					&& chars[4] == U'-'									 //
-					&& chars[7] == U'-'									 //
-					&& !is_eof()										 //
-					&& *cp == U' ')
-				{
-					const auto pre_advance_count = advance_count;
-					const auto pre_scan_traits	 = traits;
-					chars[char_count++]			 = *cp;
-					add_trait(has_t);
-
-					const auto backpedal = [&]() noexcept
-					{
-						go_back(advance_count - pre_advance_count);
-						advance_count = pre_advance_count;
-						traits		  = pre_scan_traits;
-						char_count	  = 10u;
-					};
-
-					advance_and_return_if_error({});
-					advance_count++;
-
-					if (is_eof() || !is_decimal_digit(*cp))
-						backpedal();
-					else
-					{
-						chars[char_count++] = *cp;
-
-						advance_and_return_if_error({});
-						advance_count++;
-
-						scan();
-						return_if_error({});
-
-						if (char_count == 12u)
-							backpedal();
-					}
-				}
-
-				// set the reader back to where we started
-				go_back(advance_count);
-
-				// if after scanning ahead we still only have one value character,
-				// the only valid value type is an integer.
-				if (char_count == 1u)
-				{
-					if (has_any(begins_digit))
-					{
-						val.reset(new value{ static_cast<int64_t>(chars[0] - U'0') });
-						advance(); // skip the digit
-						break;
-					}
-
-					// anything else would be ambiguous.
-					else
-						set_error_and_return_default(eof_while_scanning ? "encountered end-of-file"sv
-																		: "could not determine value type"sv);
-				}
-
-				// now things that can be identified from two or more characters
-				return_if_error({});
-				TOML_ASSERT_ASSUME(char_count >= 2u);
-
-				// do some 'fuzzy matching' where there's no ambiguity, since that allows the specific
-				// typed parse functions to take over and show better diagnostics if there's an issue
-				// (as opposed to the fallback "could not determine type" message)
-				if (has_any(has_p))
-					val.reset(new value{ parse_hex_float() });
-				else if (has_any(has_x | has_o | has_b))
-				{
-					int64_t i;
-					value_flags flags;
-					if (has_any(has_x))
-					{
-						i	  = parse_integer<16>();
-						flags = value_flags::format_as_hexadecimal;
-					}
-					else if (has_any(has_o))
-					{
-						i	  = parse_integer<8>();
-						flags = value_flags::format_as_octal;
-					}
-					else // has_b
-					{
-						i	  = parse_integer<2>();
-						flags = value_flags::format_as_binary;
-					}
-					return_if_error({});
-
-					val.reset(new value{ i });
-					val->ref_cast<int64_t>().flags(flags);
-				}
-				else if (has_any(has_e) || (has_any(begins_digit) && chars[1] == U'.'))
-					val.reset(new value{ parse_float() });
-				else if (has_any(begins_sign))
-				{
-					// single-digit signed integers
-					if (char_count == 2u && has_any(has_digits))
-					{
-						val.reset(new value{ static_cast<int64_t>(chars[1] - U'0') * (chars[0] == U'-' ? -1LL : 1LL) });
-						advance(); // skip the sign
-						advance(); // skip the digit
-						break;
-					}
-
-					// simple signed floats (e.g. +1.0)
-					if (is_decimal_digit(chars[1]) && chars[2] == U'.')
-						val.reset(new value{ parse_float() });
-
-					// signed infinity or nan
-					else if (is_match(chars[1], U'i', U'n', U'I', U'N'))
-						val.reset(new value{ parse_inf_or_nan() });
-				}
-
-				return_if_error({});
-				if (val)
-					break;
-
-				// match trait masks against what they can match exclusively.
-				// all correct value parses will come out of this list, so doing this as a switch is likely to
-				// be a better friend to the optimizer on the success path (failure path can be slow but that
-				// doesn't matter much).
-				switch (unwrap_enum(traits))
-				{
-					// binary integers
-					// 0b10
-					case bzero_msk | has_b:
-						val.reset(new value{ parse_integer<2>() });
-						val->ref_cast<int64_t>().flags(value_flags::format_as_binary);
-						break;
-
-					// octal integers
-					// 0o10
-					case bzero_msk | has_o:
-						val.reset(new value{ parse_integer<8>() });
-						val->ref_cast<int64_t>().flags(value_flags::format_as_octal);
-						break;
-
-					// decimal integers
-					// 00
-					// 10
-					// +10
-					// -10
-					case bzero_msk: [[fallthrough]];
-					case bdigit_msk: [[fallthrough]];
-					case begins_sign | has_digits | has_minus: [[fallthrough]];
-					case begins_sign | has_digits | has_plus:
-					{
-						// if the value was so long we exhausted the history buffer it's reasonable to assume
-						// there was more and the value's actual type is impossible to identify without making the
-						// buffer bigger (since it could have actually been a float), so emit an error.
-						//
-						// (this will likely only come up during fuzzing and similar scenarios)
-						static constexpr size_t max_numeric_value_length =
-							utf8_buffered_reader::max_history_length - 2u;
-						if TOML_UNLIKELY(!eof_while_scanning && advance_count > max_numeric_value_length)
-							set_error_and_return_default("numeric value too long to identify type - cannot exceed "sv,
-														 max_numeric_value_length,
-														 " characters"sv);
-
-						val.reset(new value{ parse_integer<10>() });
-						break;
-					}
-
-					// hexadecimal integers
-					// 0x10
-					case bzero_msk | has_x:
-						val.reset(new value{ parse_integer<16>() });
-						val->ref_cast<int64_t>().flags(value_flags::format_as_hexadecimal);
-						break;
-
-					// decimal floats
-					// 0e1
-					// 0e-1
-					// 0e+1
-					// 0.0
-					// 0.0e1
-					// 0.0e-1
-					// 0.0e+1
-					case bzero_msk | has_e: [[fallthrough]];
-					case bzero_msk | has_e | has_minus: [[fallthrough]];
-					case bzero_msk | has_e | has_plus: [[fallthrough]];
-					case bzero_msk | has_dot: [[fallthrough]];
-					case bzero_msk | has_dot | has_e: [[fallthrough]];
-					case bzero_msk | has_dot | has_e | has_minus: [[fallthrough]];
-					case bzero_msk | has_dot | has_e | has_plus: [[fallthrough]];
-					// 1e1
-					// 1e-1
-					// 1e+1
-					// 1.0
-					// 1.0e1
-					// 1.0e-1
-					// 1.0e+1
-					case bdigit_msk | has_e: [[fallthrough]];
-					case bdigit_msk | has_e | has_minus: [[fallthrough]];
-					case bdigit_msk | has_e | has_plus: [[fallthrough]];
-					case bdigit_msk | has_dot: [[fallthrough]];
-					case bdigit_msk | has_dot | has_e: [[fallthrough]];
-					case bdigit_msk | has_dot | has_e | has_minus: [[fallthrough]];
-					case bdigit_msk | has_dot | has_e | has_plus: [[fallthrough]];
-					// +1e1
-					// +1.0
-					// +1.0e1
-					// +1.0e+1
-					// +1.0e-1
-					// -1.0e+1
-					case begins_sign | has_digits | has_e | has_plus: [[fallthrough]];
-					case begins_sign | has_digits | has_dot | has_plus: [[fallthrough]];
-					case begins_sign | has_digits | has_dot | has_e | has_plus: [[fallthrough]];
-					case begins_sign | has_digits | has_dot | has_e | signs_msk: [[fallthrough]];
-					// -1e1
-					// -1e+1
-					// +1e-1
-					// -1.0
-					// -1.0e1
-					// -1.0e-1
-					case begins_sign | has_digits | has_e | has_minus: [[fallthrough]];
-					case begins_sign | has_digits | has_e | signs_msk: [[fallthrough]];
-					case begins_sign | has_digits | has_dot | has_minus: [[fallthrough]];
-					case begins_sign | has_digits | has_dot | has_e | has_minus:
-						val.reset(new value{ parse_float() });
-						break;
-
-					// hexadecimal floats
-					// 0x10p0
-					// 0x10p-0
-					// 0x10p+0
-					case bzero_msk | has_x | has_p: [[fallthrough]];
-					case bzero_msk | has_x | has_p | has_minus: [[fallthrough]];
-					case bzero_msk | has_x | has_p | has_plus: [[fallthrough]];
-					// -0x10p0
-					// -0x10p-0
-					// +0x10p0
-					// +0x10p+0
-					// -0x10p+0
-					// +0x10p-0
-					case begins_sign | has_digits | has_x | has_p | has_minus: [[fallthrough]];
-					case begins_sign | has_digits | has_x | has_p | has_plus: [[fallthrough]];
-					case begins_sign | has_digits | has_x | has_p | signs_msk: [[fallthrough]];
-					// 0x10.1p0
-					// 0x10.1p-0
-					// 0x10.1p+0
-					case bzero_msk | has_x | has_dot | has_p: [[fallthrough]];
-					case bzero_msk | has_x | has_dot | has_p | has_minus: [[fallthrough]];
-					case bzero_msk | has_x | has_dot | has_p | has_plus: [[fallthrough]];
-					// -0x10.1p0
-					// -0x10.1p-0
-					// +0x10.1p0
-					// +0x10.1p+0
-					// -0x10.1p+0
-					// +0x10.1p-0
-					case begins_sign | has_digits | has_x | has_dot | has_p | has_minus: [[fallthrough]];
-					case begins_sign | has_digits | has_x | has_dot | has_p | has_plus: [[fallthrough]];
-					case begins_sign | has_digits | has_x | has_dot | has_p | signs_msk:
-						val.reset(new value{ parse_hex_float() });
-						break;
-
-					// times
-					// HH:MM
-					// HH:MM:SS
-					// HH:MM:SS.FFFFFF
-					case bzero_msk | has_colon: [[fallthrough]];
-					case bzero_msk | has_colon | has_dot: [[fallthrough]];
-					case bdigit_msk | has_colon: [[fallthrough]];
-					case bdigit_msk | has_colon | has_dot: val.reset(new value{ parse_time() }); break;
-
-					// local dates
-					// YYYY-MM-DD
-					case bzero_msk | has_minus: [[fallthrough]];
-					case bdigit_msk | has_minus: val.reset(new value{ parse_date() }); break;
-
-					// date-times
-					// YYYY-MM-DDTHH:MM
-					// YYYY-MM-DDTHH:MM-HH:MM
-					// YYYY-MM-DDTHH:MM+HH:MM
-					// YYYY-MM-DD HH:MM
-					// YYYY-MM-DD HH:MM-HH:MM
-					// YYYY-MM-DD HH:MM+HH:MM
-					// YYYY-MM-DDTHH:MM:SS
-					// YYYY-MM-DDTHH:MM:SS-HH:MM
-					// YYYY-MM-DDTHH:MM:SS+HH:MM
-					// YYYY-MM-DD HH:MM:SS
-					// YYYY-MM-DD HH:MM:SS-HH:MM
-					// YYYY-MM-DD HH:MM:SS+HH:MM
-					case bzero_msk | has_minus | has_colon | has_t: [[fallthrough]];
-					case bzero_msk | signs_msk | has_colon | has_t: [[fallthrough]];
-					case bdigit_msk | has_minus | has_colon | has_t: [[fallthrough]];
-					case bdigit_msk | signs_msk | has_colon | has_t: [[fallthrough]];
-					// YYYY-MM-DDTHH:MM:SS.FFFFFF
-					// YYYY-MM-DDTHH:MM:SS.FFFFFF-HH:MM
-					// YYYY-MM-DDTHH:MM:SS.FFFFFF+HH:MM
-					// YYYY-MM-DD HH:MM:SS.FFFFFF
-					// YYYY-MM-DD HH:MM:SS.FFFFFF-HH:MM
-					// YYYY-MM-DD HH:MM:SS.FFFFFF+HH:MM
-					case bzero_msk | has_minus | has_colon | has_dot | has_t: [[fallthrough]];
-					case bzero_msk | signs_msk | has_colon | has_dot | has_t: [[fallthrough]];
-					case bdigit_msk | has_minus | has_colon | has_dot | has_t: [[fallthrough]];
-					case bdigit_msk | signs_msk | has_colon | has_dot | has_t: [[fallthrough]];
-					// YYYY-MM-DDTHH:MMZ
-					// YYYY-MM-DD HH:MMZ
-					// YYYY-MM-DDTHH:MM:SSZ
-					// YYYY-MM-DD HH:MM:SSZ
-					// YYYY-MM-DDTHH:MM:SS.FFFFFFZ
-					// YYYY-MM-DD HH:MM:SS.FFFFFFZ
-					case bzero_msk | has_minus | has_colon | has_z | has_t: [[fallthrough]];
-					case bzero_msk | has_minus | has_colon | has_dot | has_z | has_t: [[fallthrough]];
-					case bdigit_msk | has_minus | has_colon | has_z | has_t: [[fallthrough]];
-					case bdigit_msk | has_minus | has_colon | has_dot | has_z | has_t:
-						val.reset(new value{ parse_date_time() });
-						break;
-				}
-			}
-			while (false);
-
-			if (!val)
-			{
-				set_error_at(begin_pos, "could not determine value type"sv);
-				return_after_error({});
-			}
-
-			val->source_ = { begin_pos, current_position(1), reader.source_path() };
-			return val;
-		}
-
-		TOML_NEVER_INLINE
-		bool parse_key()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_bare_key_character(*cp) || is_string_delimiter(*cp));
-			push_parse_scope("key"sv);
-
-			key_buffer.clear();
-			recording_whitespace = false;
-
-			while (!is_error())
-			{
-				std::string_view key_segment;
-				const auto key_begin = current_position();
-
-				// bare_key_segment
-				if (is_bare_key_character(*cp))
-					key_segment = parse_bare_key_segment();
-
-				// "quoted key segment"
-				else if (is_string_delimiter(*cp))
-				{
-					const auto begin_pos = cp->position;
-
-					recording_whitespace = true;
-					parsed_string str	 = parse_string();
-					recording_whitespace = false;
-					return_if_error({});
-
-					if (str.was_multi_line)
-					{
-						set_error_at(begin_pos,
-									 "multi-line strings are prohibited in "sv,
-									 key_buffer.empty() ? ""sv : "dotted "sv,
-									 "keys"sv);
-						return_after_error({});
-					}
-					else
-						key_segment = str.value;
-				}
-
-				// ???
-				else
-					set_error_and_return_default("expected bare key starting character or string delimiter, saw '"sv,
-												 to_sv(*cp),
-												 "'"sv);
-
-				const auto key_end = current_position();
-
-				// whitespace following the key segment
-				consume_leading_whitespace();
-
-				// store segment
-				key_buffer.push_back(key_segment, key_begin, key_end);
-
-				// eof or no more key to come
-				if (is_eof() || *cp != U'.')
-					break;
-
-				// was a dotted key - go around again
-				advance_and_return_if_error_or_eof({});
-				consume_leading_whitespace();
-				set_error_and_return_if_eof({});
-			}
-			return_if_error({});
-
-			return true;
-		}
-
-		TOML_NODISCARD
-		key make_key(size_t segment_index) const
-		{
-			TOML_ASSERT(key_buffer.size() > segment_index);
-
-			return key{
-				key_buffer[segment_index],
-				source_region{ key_buffer.starts[segment_index], key_buffer.ends[segment_index], root.source().path }
-			};
-		}
-
-		TOML_NODISCARD
-		TOML_NEVER_INLINE
-		table* parse_table_header()
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(*cp == U'[');
-			push_parse_scope("table header"sv);
-
-			const source_position header_begin_pos = cp->position;
-			source_position header_end_pos;
-			bool is_arr = false;
-
-			// parse header
-			{
-				// skip first '['
-				advance_and_return_if_error_or_eof({});
-
-				// skip past any whitespace that followed the '['
-				const bool had_leading_whitespace = consume_leading_whitespace();
-				set_error_and_return_if_eof({});
-
-				// skip second '[' (if present)
-				if (*cp == U'[')
-				{
-					if (had_leading_whitespace)
-						set_error_and_return_default(
-							"[[array-of-table]] brackets must be contiguous (i.e. [ [ this ] ] is prohibited)"sv);
-
-					is_arr = true;
-					advance_and_return_if_error_or_eof({});
-
-					// skip past any whitespace that followed the '['
-					consume_leading_whitespace();
-					set_error_and_return_if_eof({});
-				}
-
-				// check for a premature closing ']'
-				if (*cp == U']')
-					set_error_and_return_default("tables with blank bare keys are explicitly prohibited"sv);
-
-				// get the actual key
-				start_recording();
-				parse_key();
-				stop_recording(1u);
-				return_if_error({});
-
-				// skip past any whitespace that followed the key
-				consume_leading_whitespace();
-				return_if_error({});
-				set_error_and_return_if_eof({});
-
-				// consume the closing ']'
-				if (*cp != U']')
-					set_error_and_return_default("expected ']', saw '"sv, to_sv(*cp), "'"sv);
-				if (is_arr)
-				{
-					advance_and_return_if_error_or_eof({});
-					if (*cp != U']')
-						set_error_and_return_default("expected ']', saw '"sv, to_sv(*cp), "'"sv);
-				}
-				advance_and_return_if_error({});
-				header_end_pos = current_position(1);
-
-				// handle the rest of the line after the header
-				consume_leading_whitespace();
-				if (!is_eof() && !consume_comment() && !consume_line_break())
-					set_error_and_return_default("expected a comment or whitespace, saw '"sv, to_sv(cp), "'"sv);
-			}
-			TOML_ASSERT(!key_buffer.empty());
-
-			// check if each parent is a table/table array, or can be created implicitly as a table.
-			table* parent = &root;
-			for (size_t i = 0, e = key_buffer.size() - 1u; i < e; i++)
-			{
-				const std::string_view segment = key_buffer[i];
-				auto pit					   = parent->lower_bound(segment);
-
-				// parent already existed
-				if (pit != parent->end() && pit->first == segment)
-				{
-					node& p = pit->second;
-
-					if (auto tbl = p.as_table())
-					{
-						// adding to closed inline tables is illegal
-						if (tbl->is_inline() && !impl::find(open_inline_tables.begin(), open_inline_tables.end(), tbl))
-							set_error_and_return_default("cannot insert '"sv,
-														 to_sv(recording_buffer),
-														 "' into existing inline table"sv);
-
-						parent = tbl;
-					}
-					else if (auto arr = p.as_array(); arr && impl::find(table_arrays.begin(), table_arrays.end(), arr))
-					{
-						// table arrays are a special case;
-						// the spec dictates we select the most recently declared element in the array.
-						TOML_ASSERT(!arr->empty());
-						TOML_ASSERT(arr->back().is_table());
-						parent = &arr->back().ref_cast<table>();
-					}
-					else
-					{
-						if (!is_arr && p.type() == node_type::table)
-							set_error_and_return_default("cannot redefine existing table '"sv,
-														 to_sv(recording_buffer),
-														 "'"sv);
-						else
-							set_error_and_return_default("cannot redefine existing "sv,
-														 to_sv(p.type()),
-														 " '"sv,
-														 to_sv(recording_buffer),
-														 "' as "sv,
-														 is_arr ? "array-of-tables"sv : "table"sv);
-					}
-				}
-
-				// need to create a new implicit table
-				else
-				{
-					pit		  = parent->emplace_hint<table>(pit, make_key(i));
-					table& p  = pit->second.ref_cast<table>();
-					p.source_ = { header_begin_pos, header_end_pos, reader.source_path() };
-
-					implicit_tables.push_back(&p);
-					parent = &p;
-				}
-			}
-
-			const auto last_segment = key_buffer.back();
-			auto it					= parent->lower_bound(last_segment);
-
-			// if there was already a matching node some sanity checking is necessary;
-			// this is ok if we're making an array and the existing element is already an array (new element)
-			// or if we're making a table and the existing element is an implicitly-created table (promote it),
-			// otherwise this is a redefinition error.
-			if (it != parent->end() && it->first == last_segment)
-			{
-				node& matching_node = it->second;
-				if (auto arr = matching_node.as_array();
-					is_arr && arr && impl::find(table_arrays.begin(), table_arrays.end(), arr))
-				{
-					table& tbl	= arr->emplace_back<table>();
-					tbl.source_ = { header_begin_pos, header_end_pos, reader.source_path() };
-					return &tbl;
-				}
-
-				else if (auto tbl = matching_node.as_table(); !is_arr && tbl && !implicit_tables.empty())
-				{
-					if (auto found = impl::find(implicit_tables.begin(), implicit_tables.end(), tbl);
-						found && (tbl->empty() || tbl->is_homogeneous<table>()))
-					{
-						implicit_tables.erase(implicit_tables.cbegin() + (found - implicit_tables.data()));
-						tbl->source_.begin = header_begin_pos;
-						tbl->source_.end   = header_end_pos;
-						return tbl;
-					}
-				}
-
-				// if we get here it's a redefinition error.
-				if (!is_arr && matching_node.type() == node_type::table)
-				{
-					set_error_at(header_begin_pos,
-								 "cannot redefine existing table '"sv,
-								 to_sv(recording_buffer),
-								 "'"sv);
-					return_after_error({});
-				}
-				else
-				{
-					set_error_at(header_begin_pos,
-								 "cannot redefine existing "sv,
-								 to_sv(matching_node.type()),
-								 " '"sv,
-								 to_sv(recording_buffer),
-								 "' as "sv,
-								 is_arr ? "array-of-tables"sv : "table"sv);
-					return_after_error({});
-				}
-			}
-
-			// there was no matching node, sweet - we can freely instantiate a new table/table array.
-			else
-			{
-				auto last_key = make_key(key_buffer.size() - 1u);
-
-				// if it's an array we need to make the array and it's first table element,
-				// set the starting regions, and return the table element
-				if (is_arr)
-				{
-					it			   = parent->emplace_hint<array>(it, std::move(last_key));
-					array& tbl_arr = it->second.ref_cast<array>();
-					table_arrays.push_back(&tbl_arr);
-					tbl_arr.source_ = { header_begin_pos, header_end_pos, reader.source_path() };
-
-					table& tbl	= tbl_arr.emplace_back<table>();
-					tbl.source_ = { header_begin_pos, header_end_pos, reader.source_path() };
-					return &tbl;
-				}
-
-				// otherwise we're just making a table
-				else
-				{
-					it			= parent->emplace_hint<table>(it, std::move(last_key));
-					table& tbl	= it->second.ref_cast<table>();
-					tbl.source_ = { header_begin_pos, header_end_pos, reader.source_path() };
-					return &tbl;
-				}
-			}
-		}
-
-		TOML_NEVER_INLINE
-		bool parse_key_value_pair_and_insert(table* tbl)
-		{
-			return_if_error({});
-			assert_not_eof();
-			TOML_ASSERT_ASSUME(is_string_delimiter(*cp) || is_bare_key_character(*cp));
-			push_parse_scope("key-value pair"sv);
-
-			// read the key into the key buffer
-			start_recording();
-			parse_key();
-			stop_recording(1u);
-			return_if_error({});
-			TOML_ASSERT(key_buffer.size() >= 1u);
-
-			// skip past any whitespace that followed the key
-			consume_leading_whitespace();
-			set_error_and_return_if_eof({});
-
-			// '='
-			if (*cp != U'=')
-				set_error_and_return_default("expected '=', saw '"sv, to_sv(*cp), "'"sv);
-			advance_and_return_if_error_or_eof({});
-
-			// skip past any whitespace that followed the '='
-			consume_leading_whitespace();
-			return_if_error({});
-			set_error_and_return_if_eof({});
-
-			// check that the next character could actually be a value
-			if (is_value_terminator(*cp))
-				set_error_and_return_default("expected value, saw '"sv, to_sv(*cp), "'"sv);
-
-			// if it's a dotted kvp we need to spawn the parent sub-tables if necessary,
-			// and set the target table to the second-to-last one in the chain
-			if (key_buffer.size() > 1u)
-			{
-				for (size_t i = 0; i < key_buffer.size() - 1u; i++)
-				{
-					const std::string_view segment = key_buffer[i];
-					auto pit					   = tbl->lower_bound(segment);
-
-					// parent already existed
-					if (pit != tbl->end() && pit->first == segment)
-					{
-						table* p = pit->second.as_table();
-
-						// redefinition
-						if TOML_UNLIKELY(!p
-							|| !(impl::find(dotted_key_tables.begin(), dotted_key_tables.end(), p)
-								 || impl::find(implicit_tables.begin(), implicit_tables.end(), p)))
-						{
-							set_error_at(key_buffer.starts[i],
-										 "cannot redefine existing "sv,
-										 to_sv(pit->second.type()),
-										 " as dotted key-value pair"sv);
-							return_after_error({});
-						}
-
-						tbl = p;
-					}
-
-					// need to create a new implicit table
-					else
-					{
-						pit		  = tbl->emplace_hint<table>(pit, make_key(i));
-						table& p  = pit->second.ref_cast<table>();
-						p.source_ = pit->first.source();
-
-						dotted_key_tables.push_back(&p);
-						tbl = &p;
-					}
-				}
-			}
-
-			// ensure this isn't a redefinition
-			const std::string_view last_segment = key_buffer.back();
-			auto it								= tbl->lower_bound(last_segment);
-			if (it != tbl->end() && it->first == last_segment)
-			{
-				set_error("cannot redefine existing "sv,
-						  to_sv(it->second.type()),
-						  " '"sv,
-						  to_sv(recording_buffer),
-						  "'"sv);
-				return_after_error({});
-			}
-
-			// create the key first since the key buffer will likely get overwritten during value parsing (inline
-			// tables)
-			auto last_key = make_key(key_buffer.size() - 1u);
-
-			// now we can actually parse the value
-			node_ptr val = parse_value();
-			return_if_error({});
-
-			tbl->emplace_hint<node_ptr>(it, std::move(last_key), std::move(val));
-			return true;
-		}
-
-		void parse_document()
-		{
-			assert_not_error();
-			assert_not_eof();
-			push_parse_scope("root table"sv);
-
-			table* current_table = &root;
-
-			do
-			{
-				return_if_error();
-
-				// leading whitespace, line endings, comments
-				if (consume_leading_whitespace() || consume_line_break() || consume_comment())
-					continue;
-				return_if_error();
-
-				// [tables]
-				// [[table array]]
-				if (*cp == U'[')
-					current_table = parse_table_header();
-
-				// bare_keys
-				// dotted.keys
-				// "quoted keys"
-				else if (is_bare_key_character(*cp) || is_string_delimiter(*cp))
-				{
-					push_parse_scope("key-value pair"sv);
-
-					parse_key_value_pair_and_insert(current_table);
-
-					// handle the rest of the line after the kvp
-					// (this is not done in parse_key_value_pair() because that is also used for inline tables)
-					consume_leading_whitespace();
-					return_if_error();
-					if (!is_eof() && !consume_comment() && !consume_line_break())
-						set_error("expected a comment or whitespace, saw '"sv, to_sv(cp), "'"sv);
-				}
-
-				else // ??
-					set_error("expected keys, tables, whitespace or comments, saw '"sv, to_sv(cp), "'"sv);
-			}
-			while (!is_eof());
-
-			auto eof_pos	 = current_position(1);
-			root.source_.end = eof_pos;
-			if (current_table && current_table != &root && current_table->source_.end <= current_table->source_.begin)
-				current_table->source_.end = eof_pos;
-		}
-
-		static void update_region_ends(node& nde) noexcept
-		{
-			const auto type = nde.type();
-			if (type > node_type::array)
-				return;
-
-			if (type == node_type::table)
-			{
-				auto& tbl = nde.ref_cast<table>();
-				if (tbl.is_inline()) // inline tables (and all their inline descendants) are already correctly
-									 // terminated
-					return;
-
-				auto end = nde.source_.end;
-				for (auto&& [k, v] : tbl)
-				{
-					TOML_UNUSED(k);
-					update_region_ends(v);
-					if (end < v.source_.end)
-						end = v.source_.end;
-				}
-			}
-			else // arrays
-			{
-				auto& arr = nde.ref_cast<array>();
-				auto end  = nde.source_.end;
-				for (auto&& v : arr)
-				{
-					update_region_ends(v);
-					if (end < v.source_.end)
-						end = v.source_.end;
-				}
-				nde.source_.end = end;
-			}
-		}
-
-	  public:
-		parser(utf8_reader_interface&& reader_) //
-			: reader{ reader_ }
-		{
-			root.source_ = { prev_pos, prev_pos, reader.source_path() };
-
-			if (!reader.peek_eof())
-			{
-				cp = reader.read_next();
-
-#if !TOML_EXCEPTIONS
-				if (reader.error())
-				{
-					err = std::move(reader.error());
-					return;
-				}
-#endif
-
-				if (cp)
-					parse_document();
-			}
-
-			update_region_ends(root);
-		}
-
-		TOML_NODISCARD
-		operator parse_result() && noexcept
-		{
-#if TOML_EXCEPTIONS
-
-			return { std::move(root) };
-
-#else
-
-			if (err)
-				return parse_result{ *std::move(err) };
-			else
-				return parse_result{ std::move(root) };
-
-#endif
-		}
-	};
-
-	TOML_EXTERNAL_LINKAGE
-	node_ptr parser::parse_array()
-	{
-		return_if_error({});
-		assert_not_eof();
-		TOML_ASSERT_ASSUME(*cp == U'[');
-		push_parse_scope("array"sv);
-
-		// skip opening '['
-		advance_and_return_if_error_or_eof({});
-
-		node_ptr arr_ptr{ new array{} };
-		array& arr = arr_ptr->ref_cast<array>();
-		enum class TOML_CLOSED_ENUM parse_type : int
-		{
-			none,
-			comma,
-			val
-		};
-		parse_type prev = parse_type::none;
-
-		while (!is_error())
-		{
-			while (consume_leading_whitespace() || consume_line_break() || consume_comment())
-				continue;
-			set_error_and_return_if_eof({});
-
-			// commas - only legal after a value
-			if (*cp == U',')
-			{
-				if (prev == parse_type::val)
-				{
-					prev = parse_type::comma;
-					advance_and_return_if_error_or_eof({});
-					continue;
-				}
-				set_error_and_return_default("expected value or closing ']', saw comma"sv);
-			}
-
-			// closing ']'
-			else if (*cp == U']')
-			{
-				advance_and_return_if_error({});
-				break;
-			}
-
-			// must be a value
-			else
-			{
-				if (prev == parse_type::val)
-				{
-					set_error_and_return_default("expected comma or closing ']', saw '"sv, to_sv(*cp), "'"sv);
-					continue;
-				}
-				prev = parse_type::val;
-
-				auto val = parse_value();
-				return_if_error({});
-
-				if (!arr.capacity())
-					arr.reserve(4u);
-				arr.emplace_back<node_ptr>(std::move(val));
-			}
-		}
-
-		return_if_error({});
-		return arr_ptr;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	node_ptr parser::parse_inline_table()
-	{
-		return_if_error({});
-		assert_not_eof();
-		TOML_ASSERT_ASSUME(*cp == U'{');
-		push_parse_scope("inline table"sv);
-
-		// skip opening '{'
-		advance_and_return_if_error_or_eof({});
-
-		node_ptr tbl_ptr{ new table{} };
-		table& tbl = tbl_ptr->ref_cast<table>();
-		tbl.is_inline(true);
-		table_vector_scope table_scope{ open_inline_tables, tbl };
-
-		enum class TOML_CLOSED_ENUM parse_type : int
-		{
-			none,
-			comma,
-			kvp
-		};
-		parse_type prev = parse_type::none;
-		while (!is_error())
-		{
-			if constexpr (TOML_LANG_UNRELEASED) // toml/issues/516 (newlines/trailing commas in inline tables)
-			{
-				while (consume_leading_whitespace() || consume_line_break() || consume_comment())
-					continue;
-			}
-			else
-			{
-				while (consume_leading_whitespace())
-					continue;
-			}
-			return_if_error({});
-			set_error_and_return_if_eof({});
-
-			// commas - only legal after a key-value pair
-			if (*cp == U',')
-			{
-				if (prev == parse_type::kvp)
-				{
-					prev = parse_type::comma;
-					advance_and_return_if_error_or_eof({});
-				}
-				else
-					set_error_and_return_default("expected key-value pair or closing '}', saw comma"sv);
-			}
-
-			// closing '}'
-			else if (*cp == U'}')
-			{
-				if constexpr (!TOML_LANG_UNRELEASED) // toml/issues/516 (newlines/trailing commas in inline tables)
-				{
-					if (prev == parse_type::comma)
-					{
-						set_error_and_return_default("expected key-value pair, saw closing '}' (dangling comma)"sv);
-						continue;
-					}
-				}
-				advance_and_return_if_error({});
-				break;
-			}
-
-			// key-value pair
-			else if (is_string_delimiter(*cp) || is_bare_key_character(*cp))
-			{
-				if (prev == parse_type::kvp)
-					set_error_and_return_default("expected comma or closing '}', saw '"sv, to_sv(*cp), "'"sv);
-				else
-				{
-					prev = parse_type::kvp;
-					parse_key_value_pair_and_insert(&tbl);
-				}
-			}
-
-			else
-				set_error_and_return_default("expected key or closing '}', saw '"sv, to_sv(*cp), "'"sv);
-		}
-
-		return_if_error({});
-		return tbl_ptr;
-	}
-
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-}
-TOML_IMPL_NAMESPACE_END;
-
-#undef TOML_RETURNS_BY_THROWING
-#undef advance_and_return_if_error
-#undef advance_and_return_if_error_or_eof
-#undef assert_not_eof
-#undef assert_not_error
-#undef is_eof
-#undef is_error
-#undef parse_error_break
-#undef push_parse_scope
-#undef push_parse_scope_1
-#undef push_parse_scope_2
-#undef return_after_error
-#undef return_if_eof
-#undef return_if_error
-#undef return_if_error_or_eof
-#undef set_error_and_return
-#undef set_error_and_return_default
-#undef set_error_and_return_if_eof
-#undef utf8_buffered_reader_error_check
-#undef utf8_reader_error
-#undef utf8_reader_error_check
-#undef utf8_reader_return_after_error
-
-TOML_ANON_NAMESPACE_START
-{
-	TOML_NODISCARD
-	TOML_INTERNAL_LINKAGE
-	parse_result do_parse(utf8_reader_interface && reader)
-	{
-		return impl::parser{ std::move(reader) };
-	}
-
-	TOML_NODISCARD
-	TOML_INTERNAL_LINKAGE
-	parse_result do_parse_file(std::string_view file_path)
-	{
-#if TOML_EXCEPTIONS
-#define TOML_PARSE_FILE_ERROR(msg, path)                                                                               \
-	throw parse_error{ msg, source_position{}, std::make_shared<const std::string>(std::move(path)) }
-#else
-#define TOML_PARSE_FILE_ERROR(msg, path)                                                                               \
-	return parse_result                                                                                                \
-	{                                                                                                                  \
-		parse_error                                                                                                    \
-		{                                                                                                              \
-			msg, source_position{}, std::make_shared<const std::string>(std::move(path))                               \
-		}                                                                                                              \
-	}
-#endif
-
-		std::string file_path_str(file_path);
-
-		// open file with a custom-sized stack buffer
-		std::ifstream file;
-		TOML_OVERALIGNED char file_buffer[sizeof(void*) * 1024u];
-		file.rdbuf()->pubsetbuf(file_buffer, sizeof(file_buffer));
-#if TOML_WINDOWS
-		file.open(impl::widen(file_path_str), std::ifstream::in | std::ifstream::binary | std::ifstream::ate);
-#else
-		file.open(file_path_str, std::ifstream::in | std::ifstream::binary | std::ifstream::ate);
-#endif
-		if (!file.is_open())
-			TOML_PARSE_FILE_ERROR("File could not be opened for reading", file_path_str);
-
-		// get size
-		const auto file_size = file.tellg();
-		if (file_size == -1)
-			TOML_PARSE_FILE_ERROR("Could not determine file size", file_path_str);
-		file.seekg(0, std::ifstream::beg);
-
-		// read the whole file into memory first if the file isn't too large
-		constexpr auto large_file_threshold = 1024 * 1024 * 2; // 2 MB
-		if (file_size <= large_file_threshold)
-		{
-			std::vector<char> file_data;
-			file_data.resize(static_cast<size_t>(file_size));
-			file.read(file_data.data(), static_cast<std::streamsize>(file_size));
-			return parse(std::string_view{ file_data.data(), file_data.size() }, std::move(file_path_str));
-		}
-
-		// otherwise parse it using the streams
-		else
-			return parse(file, std::move(file_path_str));
-
-#undef TOML_PARSE_FILE_ERROR
-	}
-}
-TOML_ANON_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex);
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::string_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::string && source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::string_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::string && source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse_file(std::string_view file_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse_file(file_path);
-	}
-
-#if TOML_HAS_CHAR8
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, source_path });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::string && source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, std::move(source_path) });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse_file(std::u8string_view file_path)
-	{
-		std::string file_path_str;
-		file_path_str.resize(file_path.length());
-		memcpy(file_path_str.data(), file_path.data(), file_path.length());
-		return TOML_ANON_NAMESPACE::do_parse_file(file_path_str);
-	}
-
-#endif // TOML_HAS_CHAR8
-
-#if TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::string_view doc, std::wstring_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::istream & doc, std::wstring_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse_file(std::wstring_view file_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse_file(impl::narrow(file_path));
-	}
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-#if TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_EXTERNAL_LINKAGE
-	parse_result TOML_CALLCONV parse(std::u8string_view doc, std::wstring_view source_path)
-	{
-		return TOML_ANON_NAMESPACE::do_parse(TOML_ANON_NAMESPACE::utf8_reader{ doc, impl::narrow(source_path) });
-	}
-
-#endif // TOML_HAS_CHAR8 && TOML_ENABLE_WINDOWS_COMPAT
-
-	TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS
-}
-TOML_NAMESPACE_END;
-
-#undef TOML_OVERALIGNED
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_PARSER
-
-//********  impl/formatter.inl  ****************************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_IMPL_NAMESPACE_START
-{
-	enum class TOML_CLOSED_FLAGS_ENUM formatted_string_traits : unsigned
-	{
-		none,
-		line_breaks	  = 1u << 0, // \n
-		tabs		  = 1u << 1, // \t
-		control_chars = 1u << 2, // also includes non-ascii vertical whitespace
-		single_quotes = 1u << 3,
-		non_bare	  = 1u << 4, // anything not satisfying "is bare key character"
-		non_ascii	  = 1u << 5, // any codepoint >= 128
-
-		all = (non_ascii << 1u) - 1u
-	};
-	TOML_MAKE_FLAGS(formatted_string_traits);
-
-	TOML_EXTERNAL_LINKAGE
-	formatter::formatter(const node* source_node,
-						 const parse_result* source_pr,
-						 const formatter_constants& constants,
-						 const formatter_config& config) noexcept //
-#if TOML_ENABLE_PARSER && !TOML_EXCEPTIONS
-		: source_{ source_pr && *source_pr ? &source_pr->table() : source_node },
-		  result_{ source_pr },
-#else
-		: source_{ source_pr ? source_pr : source_node },
-#endif
-		  constants_{ &constants },
-		  config_{ config }
-	{
-		TOML_ASSERT_ASSUME(source_);
-
-		config_.flags = (config_.flags | constants_->mandatory_flags) & ~constants_->ignored_flags;
-
-		indent_columns_ = {};
-		for (auto c : config_.indent)
-			indent_columns_ += c == '\t' ? 4u : 1u;
-
-		int_format_mask_ = config_.flags
-						 & (format_flags::allow_binary_integers | format_flags::allow_octal_integers
-							| format_flags::allow_hexadecimal_integers);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::attach(std::ostream & stream) noexcept
-	{
-		indent_		   = {};
-		naked_newline_ = true;
-		stream_		   = &stream;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::detach() noexcept
-	{
-		stream_ = nullptr;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_newline(bool force)
-	{
-		if (!naked_newline_ || force)
-		{
-			print_to_stream(*stream_, '\n');
-			naked_newline_ = true;
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_indent()
-	{
-		for (int i = 0; i < indent_; i++)
-		{
-			print_to_stream(*stream_, config_.indent);
-			naked_newline_ = false;
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_unformatted(char c)
-	{
-		print_to_stream(*stream_, c);
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_unformatted(std::string_view str)
-	{
-		print_to_stream(*stream_, str);
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_string(std::string_view str, bool allow_multi_line, bool allow_bare)
-	{
-		if (str.empty())
-		{
-			print_unformatted(literal_strings_allowed() ? "''"sv : "\"\""sv);
-			return;
-		}
-
-		// pre-scan the string to determine how we should output it
-		formatted_string_traits traits = {};
-
-		if (!allow_bare)
-			traits |= formatted_string_traits::non_bare;
-		bool unicode_allowed = unicode_strings_allowed();
-
-		// ascii fast path
-		if (is_ascii(str.data(), str.length()))
-		{
-			for (auto c : str)
-			{
-				switch (c)
-				{
-					case '\n': traits |= formatted_string_traits::line_breaks; break;
-					case '\t': traits |= formatted_string_traits::tabs; break;
-					case '\'': traits |= formatted_string_traits::single_quotes; break;
-					default:
-					{
-						if TOML_UNLIKELY(is_control_character(c))
-							traits |= formatted_string_traits::control_chars;
-
-						if (!is_ascii_bare_key_character(static_cast<char32_t>(c)))
-							traits |= formatted_string_traits::non_bare;
-						break;
-					}
-				}
-
-				static constexpr auto all_ascii_traits =
-					formatted_string_traits::all & ~formatted_string_traits::non_ascii;
-				if (traits == all_ascii_traits)
-					break;
-			}
-		}
-
-		// unicode slow path
-		else
-		{
-			traits |= formatted_string_traits::non_ascii;
-			utf8_decoder decoder;
-
-			// if the unicode is malformed just treat the string as a single-line non-literal and
-			// escape all non-ascii characters (to ensure round-tripping and help with diagnostics)
-			const auto bad_unicode = [&]() noexcept
-			{
-				traits &= ~formatted_string_traits::line_breaks;
-				traits |= formatted_string_traits::control_chars | formatted_string_traits::non_bare;
-				unicode_allowed = false;
-			};
-
-			for (auto c : str)
-			{
-				decoder(c);
-
-				if TOML_UNLIKELY(decoder.error())
-				{
-					bad_unicode();
-					break;
-				}
-
-				if (!decoder.has_code_point())
-					continue;
-
-				switch (decoder.codepoint)
-				{
-					case U'\n': traits |= formatted_string_traits::line_breaks; break;
-					case U'\t': traits |= formatted_string_traits::tabs; break;
-					case U'\'': traits |= formatted_string_traits::single_quotes; break;
-					default:
-					{
-						if TOML_UNLIKELY(is_control_character(decoder.codepoint)
-							|| is_non_ascii_vertical_whitespace(decoder.codepoint))
-							traits |= formatted_string_traits::control_chars;
-
-						if (!is_bare_key_character(decoder.codepoint))
-							traits |= formatted_string_traits::non_bare;
-						break;
-					}
-				}
-			}
-
-			if (decoder.needs_more_input())
-				bad_unicode();
-		}
-
-		// if the string meets the requirements of being 'bare' we can emit a bare string
-		// (bare strings are composed of letters and numbers; no whitespace, control chars, quotes, etc)
-		if (!(traits & formatted_string_traits::non_bare)
-			&& (!(traits & formatted_string_traits::non_ascii) || unicode_allowed))
-		{
-			print_unformatted(str);
-			return;
-		}
-
-		// determine if this should be a multi-line string (triple-quotes)
-		const auto multi_line = allow_multi_line			 //
-							 && multi_line_strings_allowed() //
-							 && !!(traits & formatted_string_traits::line_breaks);
-
-		// determine if this should be a literal string (single-quotes with no escaping)
-		const auto literal = literal_strings_allowed()													   //
-						  && !(traits & formatted_string_traits::control_chars)							   //
-						  && (!(traits & formatted_string_traits::single_quotes) || multi_line)			   //
-						  && (!(traits & formatted_string_traits::tabs) || real_tabs_in_strings_allowed()) //
-						  && (!(traits & formatted_string_traits::non_ascii) || unicode_allowed);
-
-		// literal strings (single quotes, no escape codes)
-		if (literal)
-		{
-			const auto quot = multi_line ? R"(''')"sv : R"(')"sv;
-			print_unformatted(quot);
-			print_unformatted(str);
-			print_unformatted(quot);
-			return;
-		}
-
-		// anything from here down is a non-literal string, so requires iteration and escaping.
-		print_unformatted(multi_line ? R"(""")"sv : R"(")"sv);
-
-		const auto real_tabs_allowed = real_tabs_in_strings_allowed();
-
-		// ascii fast path
-		if (!(traits & formatted_string_traits::non_ascii))
-		{
-			for (auto c : str)
-			{
-				switch (c)
-				{
-					case '"': print_to_stream(*stream_, R"(\")"sv); break;
-					case '\\': print_to_stream(*stream_, R"(\\)"sv); break;
-					case '\x7F': print_to_stream(*stream_, R"(\u007F)"sv); break;
-					case '\t': print_to_stream(*stream_, real_tabs_allowed ? "\t"sv : R"(\t)"sv); break;
-					case '\n': print_to_stream(*stream_, multi_line ? "\n"sv : R"(\n)"sv); break;
-					default:
-					{
-						// control characters from lookup table
-						if TOML_UNLIKELY(c >= '\x00' && c <= '\x1F')
-							print_to_stream(*stream_, control_char_escapes[c]);
-
-						// regular characters
-						else
-							print_to_stream(*stream_, c);
-					}
-				}
-			}
-		}
-
-		// unicode slow path
-		else
-		{
-			utf8_decoder decoder;
-			const char* cp_start = str.data();
-			const char* cp_end	 = cp_start;
-			for (auto c : str)
-			{
-				decoder(c);
-				cp_end++;
-
-				// if the decoder encounters malformed unicode just emit raw bytes and
-				if (decoder.error())
-				{
-					while (cp_start != cp_end)
-					{
-						print_to_stream(*stream_, R"(\u00)"sv);
-						print_to_stream(*stream_,
-										static_cast<uint8_t>(*cp_start),
-										value_flags::format_as_hexadecimal,
-										2);
-						cp_start++;
-					}
-					decoder.reset();
-					continue;
-				}
-
-				if (!decoder.has_code_point())
-					continue;
-
-				switch (decoder.codepoint)
-				{
-					case U'"': print_to_stream(*stream_, R"(\")"sv); break;
-					case U'\\': print_to_stream(*stream_, R"(\\)"sv); break;
-					case U'\x7F': print_to_stream(*stream_, R"(\u007F)"sv); break;
-					case U'\t': print_to_stream(*stream_, real_tabs_allowed ? "\t"sv : R"(\t)"sv); break;
-					case U'\n': print_to_stream(*stream_, multi_line ? "\n"sv : R"(\n)"sv); break;
-					default:
-					{
-						// control characters from lookup table
-						if TOML_UNLIKELY(decoder.codepoint <= U'\x1F')
-							print_to_stream(*stream_,
-											control_char_escapes[static_cast<uint_least32_t>(decoder.codepoint)]);
-
-						// escaped unicode characters
-						else if (decoder.codepoint > U'\x7F'
-								 && (!unicode_allowed || is_non_ascii_vertical_whitespace(decoder.codepoint)))
-						{
-							if (static_cast<uint_least32_t>(decoder.codepoint) > 0xFFFFu)
-							{
-								print_to_stream(*stream_, R"(\U)"sv);
-								print_to_stream(*stream_,
-												static_cast<uint_least32_t>(decoder.codepoint),
-												value_flags::format_as_hexadecimal,
-												8);
-							}
-							else
-							{
-								print_to_stream(*stream_, R"(\u)"sv);
-								print_to_stream(*stream_,
-												static_cast<uint_least32_t>(decoder.codepoint),
-												value_flags::format_as_hexadecimal,
-												4);
-							}
-						}
-
-						// regular characters
-						else
-							print_to_stream(*stream_, cp_start, static_cast<size_t>(cp_end - cp_start));
-					}
-				}
-
-				cp_start = cp_end;
-			}
-		}
-
-		print_unformatted(multi_line ? R"(""")"sv : R"(")"sv);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<std::string>& val)
-	{
-		print_string(val.get());
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<int64_t>& val)
-	{
-		naked_newline_ = false;
-
-		if (*val >= 0 && !!int_format_mask_)
-		{
-			static constexpr auto value_flags_mask =
-				value_flags::format_as_binary | value_flags::format_as_octal | value_flags::format_as_hexadecimal;
-
-			const auto fmt = val.flags() & value_flags_mask;
-			switch (fmt)
-			{
-				case value_flags::format_as_binary:
-					if (!!(int_format_mask_ & format_flags::allow_binary_integers))
-					{
-						print_to_stream(*stream_, "0b"sv);
-						print_to_stream(*stream_, *val, fmt);
-						return;
-					}
-					break;
-
-				case value_flags::format_as_octal:
-					if (!!(int_format_mask_ & format_flags::allow_octal_integers))
-					{
-						print_to_stream(*stream_, "0o"sv);
-						print_to_stream(*stream_, *val, fmt);
-						return;
-					}
-					break;
-
-				case value_flags::format_as_hexadecimal:
-					if (!!(int_format_mask_ & format_flags::allow_hexadecimal_integers))
-					{
-						print_to_stream(*stream_, "0x"sv);
-						print_to_stream(*stream_, *val, fmt);
-						return;
-					}
-					break;
-
-				default: break;
-			}
-		}
-
-		// fallback to decimal
-		print_to_stream(*stream_, *val);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<double>& val)
-	{
-		const std::string_view* inf_nan = nullptr;
-		switch (fpclassify(*val))
-		{
-			case fp_class::neg_inf: inf_nan = &constants_->float_neg_inf; break;
-			case fp_class::pos_inf: inf_nan = &constants_->float_pos_inf; break;
-			case fp_class::nan: inf_nan = &constants_->float_nan; break;
-			case fp_class::ok:
-				print_to_stream(*stream_,
-								*val,
-								value_flags::none,
-								!!(config_.flags & format_flags::relaxed_float_precision));
-				break;
-			default: TOML_UNREACHABLE;
-		}
-
-		if (inf_nan)
-		{
-			if (!!(config_.flags & format_flags::quote_infinities_and_nans))
-				print_to_stream_bookended(*stream_, *inf_nan, '"');
-			else
-				print_to_stream(*stream_, *inf_nan);
-		}
-
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<bool>& val)
-	{
-		print_unformatted(*val ? constants_->bool_true : constants_->bool_false);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<date>& val)
-	{
-		if (!!(config_.flags & format_flags::quote_dates_and_times))
-			print_to_stream_bookended(*stream_, *val, literal_strings_allowed() ? '\'' : '"');
-		else
-			print_to_stream(*stream_, *val);
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<time>& val)
-	{
-		if (!!(config_.flags & format_flags::quote_dates_and_times))
-			print_to_stream_bookended(*stream_, *val, literal_strings_allowed() ? '\'' : '"');
-		else
-			print_to_stream(*stream_, *val);
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print(const value<date_time>& val)
-	{
-		if (!!(config_.flags & format_flags::quote_dates_and_times))
-			print_to_stream_bookended(*stream_, *val, literal_strings_allowed() ? '\'' : '"');
-		else
-			print_to_stream(*stream_, *val);
-		naked_newline_ = false;
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void formatter::print_value(const node& val_node, node_type type)
-	{
-		TOML_ASSUME(type > node_type::array);
-		switch (type)
-		{
-			case node_type::string: print(*reinterpret_cast<const value<std::string>*>(&val_node)); break;
-			case node_type::integer: print(*reinterpret_cast<const value<int64_t>*>(&val_node)); break;
-			case node_type::floating_point: print(*reinterpret_cast<const value<double>*>(&val_node)); break;
-			case node_type::boolean: print(*reinterpret_cast<const value<bool>*>(&val_node)); break;
-			case node_type::date: print(*reinterpret_cast<const value<date>*>(&val_node)); break;
-			case node_type::time: print(*reinterpret_cast<const value<time>*>(&val_node)); break;
-			case node_type::date_time: print(*reinterpret_cast<const value<date_time>*>(&val_node)); break;
-			default: TOML_UNREACHABLE;
-		}
-	}
-
-#if TOML_ENABLE_PARSER && !TOML_EXCEPTIONS
-
-	TOML_EXTERNAL_LINKAGE
-	bool formatter::dump_failed_parse_result()
-	{
-		if (result_ && !(*result_))
-		{
-			stream() << result_->error();
-			return true;
-		}
-		return false;
-	}
-
-#else
-
-	TOML_EXTERNAL_LINKAGE
-	TOML_ATTR(const)
-	bool formatter::dump_failed_parse_result()
-	{
-		return false;
-	}
-
-#endif
-}
-TOML_IMPL_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/toml_formatter.inl  ***********************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_DISABLE_ARITHMETIC_WARNINGS;
-
-TOML_ANON_NAMESPACE_START
-{
-	TOML_INTERNAL_LINKAGE
-	size_t toml_formatter_count_inline_columns(const node& node, size_t line_wrap_cols) noexcept
-	{
-		switch (node.type())
-		{
-			case node_type::table:
-			{
-				auto& tbl = *reinterpret_cast<const table*>(&node);
-				if (tbl.empty())
-					return 2u;		// "{}"
-				size_t weight = 3u; // "{ }"
-				for (auto&& [k, v] : tbl)
-				{
-					weight += k.length() + toml_formatter_count_inline_columns(v, line_wrap_cols) + 2u; // +  ", "
-					if (weight >= line_wrap_cols)
-						break;
-				}
-				return weight;
-			}
-
-			case node_type::array:
-			{
-				auto& arr = *reinterpret_cast<const array*>(&node);
-				if (arr.empty())
-					return 2u;		// "[]"
-				size_t weight = 3u; // "[ ]"
-				for (auto& elem : arr)
-				{
-					weight += toml_formatter_count_inline_columns(elem, line_wrap_cols) + 2u; // +  ", "
-					if (weight >= line_wrap_cols)
-						break;
-				}
-				return weight;
-			}
-
-			case node_type::string:
-			{
-				// todo: proper utf8 decoding?
-				// todo: tab awareness?
-				auto& str = (*reinterpret_cast<const value<std::string>*>(&node)).get();
-				return str.length() + 2u; // + ""
-			}
-
-			case node_type::integer:
-			{
-				auto val = (*reinterpret_cast<const value<int64_t>*>(&node)).get();
-				if (!val)
-					return 1u;
-				size_t weight = {};
-				if (val < 0)
-				{
-					weight += 1u;
-					val *= -1;
-				}
-				return weight + static_cast<size_t>(log10(static_cast<double>(val))) + 1u;
-			}
-
-			case node_type::floating_point:
-			{
-				auto val = (*reinterpret_cast<const value<double>*>(&node)).get();
-				if (val == 0.0)
-					return 3u;		// "0.0"
-				size_t weight = 2u; // ".0"
-				if (val < 0.0)
-				{
-					weight += 1u;
-					val *= -1.0;
-				}
-				return weight + static_cast<size_t>(log10(val)) + 1u;
-				break;
-			}
-
-			case node_type::boolean: return 5u;
-			case node_type::date: [[fallthrough]];
-			case node_type::time: return 10u;
-			case node_type::date_time: return 30u;
-			case node_type::none: TOML_UNREACHABLE;
-			default: TOML_UNREACHABLE;
-		}
-
-		TOML_UNREACHABLE;
-	}
-
-	TOML_INTERNAL_LINKAGE
-	bool toml_formatter_forces_multiline(const node& node, size_t line_wrap_cols, size_t starting_column_bias) noexcept
-	{
-		return (toml_formatter_count_inline_columns(node, line_wrap_cols) + starting_column_bias) >= line_wrap_cols;
-	}
-}
-TOML_ANON_NAMESPACE_END;
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print_pending_table_separator()
-	{
-		if (pending_table_separator_)
-		{
-			print_newline(true);
-			print_newline(true);
-			pending_table_separator_ = false;
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print(const key& k)
-	{
-		print_string(k.str(), false, true);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print_inline(const table& tbl)
-	{
-		if (tbl.empty())
-		{
-			print_unformatted("{}"sv);
-			return;
-		}
-
-		print_unformatted("{ "sv);
-
-		bool first = false;
-		for (auto&& [k, v] : tbl)
-		{
-			if (first)
-				print_unformatted(", "sv);
-			first = true;
-
-			print(k);
-			if (terse_kvps())
-				print_unformatted("="sv);
-			else
-				print_unformatted(" = "sv);
-
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print_inline(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-
-		print_unformatted(" }"sv);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print(const array& arr)
-	{
-		if (arr.empty())
-		{
-			print_unformatted("[]"sv);
-			return;
-		}
-
-		const auto original_indent = indent();
-		const auto multiline	   = TOML_ANON_NAMESPACE::toml_formatter_forces_multiline(
-			  arr,
-			  120u,
-			  indent_columns() * static_cast<size_t>(original_indent < 0 ? 0 : original_indent));
-
-		print_unformatted("["sv);
-
-		if (multiline)
-		{
-			if (original_indent < 0)
-				indent(0);
-			if (indent_array_elements())
-				increase_indent();
-		}
-		else
-			print_unformatted(' ');
-
-		for (size_t i = 0; i < arr.size(); i++)
-		{
-			if (i > 0u)
-			{
-				print_unformatted(',');
-				if (!multiline)
-					print_unformatted(' ');
-			}
-
-			if (multiline)
-			{
-				print_newline(true);
-				print_indent();
-			}
-
-			auto& v			= arr[i];
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print_inline(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-		if (multiline)
-		{
-			indent(original_indent);
-			print_newline(true);
-			print_indent();
-		}
-		else
-			print_unformatted(' ');
-
-		print_unformatted("]"sv);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print(const table& tbl)
-	{
-		static constexpr auto is_non_inline_array_of_tables = [](const node& n) noexcept
-		{
-			const auto arr = n.as_array();
-			if (!arr || !arr->is_array_of_tables())
-				return false;
-
-			return !reinterpret_cast<const table*>(&(*arr)[0])->is_inline();
-		};
-
-		// values, arrays, and inline tables/table arrays
-		for (auto&& [k, v] : tbl)
-		{
-			const auto type = v.type();
-			if ((type == node_type::table && !reinterpret_cast<const table*>(&v)->is_inline())
-				|| (type == node_type::array && is_non_inline_array_of_tables(v)))
-				continue;
-
-			pending_table_separator_ = true;
-			print_newline();
-			print_indent();
-			print(k);
-			if (terse_kvps())
-				print_unformatted("="sv);
-			else
-				print_unformatted(" = "sv);
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print_inline(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-
-		const auto print_key_path = [&]()
-		{
-			size_t i{};
-			for (const auto k : key_path_)
-			{
-				if (i++)
-					print_unformatted('.');
-				print(*k);
-			}
-		};
-
-		// non-inline tables
-		for (auto&& [k, v] : tbl)
-		{
-			const auto type = v.type();
-			if (type != node_type::table || reinterpret_cast<const table*>(&v)->is_inline())
-				continue;
-			auto& child_tbl = *reinterpret_cast<const table*>(&v);
-
-			// we can skip indenting and emitting the headers for tables that only contain other tables
-			// (so we don't over-nest)
-			size_t child_value_count{}; // includes inline tables and non-table arrays
-			size_t child_table_count{};
-			size_t child_table_array_count{};
-			for (auto&& [child_k, child_v] : child_tbl)
-			{
-				TOML_UNUSED(child_k);
-				const auto child_type = child_v.type();
-				TOML_ASSUME(child_type != node_type::none);
-				switch (child_type)
-				{
-					case node_type::table:
-						if (reinterpret_cast<const table*>(&child_v)->is_inline())
-							child_value_count++;
-						else
-							child_table_count++;
-						break;
-
-					case node_type::array:
-						if (is_non_inline_array_of_tables(child_v))
-							child_table_array_count++;
-						else
-							child_value_count++;
-						break;
-
-					default: child_value_count++;
-				}
-			}
-			bool skip_self = false;
-			if (child_value_count == 0u && (child_table_count > 0u || child_table_array_count > 0u))
-				skip_self = true;
-
-			key_path_.push_back(&k);
-
-			if (!skip_self)
-			{
-				print_pending_table_separator();
-				if (indent_sub_tables())
-					increase_indent();
-				print_indent();
-				print_unformatted("["sv);
-				print_key_path();
-				print_unformatted("]"sv);
-				pending_table_separator_ = true;
-			}
-
-			print(child_tbl);
-
-			key_path_.pop_back();
-			if (!skip_self && indent_sub_tables())
-				decrease_indent();
-		}
-
-		// table arrays
-		for (auto&& [k, v] : tbl)
-		{
-			if (!is_non_inline_array_of_tables(v))
-				continue;
-			auto& arr = *reinterpret_cast<const array*>(&v);
-
-			if (indent_sub_tables())
-				increase_indent();
-			key_path_.push_back(&k);
-
-			for (size_t i = 0; i < arr.size(); i++)
-			{
-				print_pending_table_separator();
-				print_indent();
-				print_unformatted("[["sv);
-				print_key_path();
-				print_unformatted("]]"sv);
-				pending_table_separator_ = true;
-				print(*reinterpret_cast<const table*>(&arr[i]));
-			}
-
-			key_path_.pop_back();
-			if (indent_sub_tables())
-				decrease_indent();
-		}
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void toml_formatter::print()
-	{
-		if (dump_failed_parse_result())
-			return;
-
-		switch (auto source_type = source().type())
-		{
-			case node_type::table:
-			{
-				auto& tbl = *reinterpret_cast<const table*>(&source());
-				if (tbl.is_inline())
-					print_inline(tbl);
-				else
-				{
-					decrease_indent(); // so root kvps and tables have the same indent
-					print(tbl);
-				}
-				break;
-			}
-
-			case node_type::array: print(*reinterpret_cast<const array*>(&source())); break;
-
-			default: print_value(source(), source_type);
-		}
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/json_formatter.inl  ***********************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	void json_formatter::print(const toml::table& tbl)
-	{
-		if (tbl.empty())
-		{
-			print_unformatted("{}"sv);
-			return;
-		}
-
-		print_unformatted('{');
-
-		if (indent_sub_tables())
-			increase_indent();
-		bool first = false;
-		for (auto&& [k, v] : tbl)
-		{
-			if (first)
-				print_unformatted(',');
-			first = true;
-			print_newline(true);
-			print_indent();
-
-			print_string(k.str(), false);
-			if (terse_kvps())
-				print_unformatted(":"sv);
-			else
-				print_unformatted(" : "sv);
-
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-		if (indent_sub_tables())
-			decrease_indent();
-		print_newline(true);
-		print_indent();
-
-		print_unformatted('}');
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void json_formatter::print(const toml::array& arr)
-	{
-		if (arr.empty())
-		{
-			print_unformatted("[]"sv);
-			return;
-		}
-
-		print_unformatted('[');
-		if (indent_array_elements())
-			increase_indent();
-		for (size_t i = 0; i < arr.size(); i++)
-		{
-			if (i > 0u)
-				print_unformatted(',');
-			print_newline(true);
-			print_indent();
-
-			auto& v			= arr[i];
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-		if (indent_array_elements())
-			decrease_indent();
-		print_newline(true);
-		print_indent();
-		print_unformatted(']');
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void json_formatter::print()
-	{
-		if (dump_failed_parse_result())
-			return;
-
-		switch (auto source_type = source().type())
-		{
-			case node_type::table: print(*reinterpret_cast<const table*>(&source())); break;
-			case node_type::array: print(*reinterpret_cast<const array*>(&source())); break;
-			default: print_value(source(), source_type);
-		}
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-//********  impl/yaml_formatter.inl  ***********************************************************************************
-
-#if TOML_ENABLE_FORMATTERS
-
-TOML_PUSH_WARNINGS;
-#ifdef _MSC_VER
-#pragma inline_recursion(on)
-#pragma push_macro("min")
-#pragma push_macro("max")
-#undef min
-#undef max
-#endif
-
-TOML_NAMESPACE_START
-{
-	TOML_EXTERNAL_LINKAGE
-	void yaml_formatter::print_yaml_string(const value<std::string>& str)
-	{
-		if (str->empty())
-		{
-			base::print(str);
-			return;
-		}
-
-		bool contains_newline = false;
-		for (auto c = str->c_str(), e = str->c_str() + str->length(); c < e && !contains_newline; c++)
-			contains_newline = *c == '\n';
-
-		if (contains_newline)
-		{
-			print_unformatted("|-"sv);
-
-			increase_indent();
-
-			auto line_end  = str->c_str() - 1u;
-			const auto end = str->c_str() + str->length();
-			while (line_end != end)
-			{
-				auto line_start = line_end + 1u;
-				line_end		= line_start;
-				for (; line_end != end && *line_end != '\n'; line_end++)
-					;
-
-				if TOML_LIKELY(line_start != line_end || line_end != end)
-				{
-					print_newline();
-					print_indent();
-					print_unformatted(std::string_view{ line_start, static_cast<size_t>(line_end - line_start) });
-				}
-			}
-
-			decrease_indent();
-		}
-		else
-			print_string(*str, false, true);
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void yaml_formatter::print(const toml::table& tbl, bool parent_is_array)
-	{
-		if (tbl.empty())
-		{
-			print_unformatted("{}"sv);
-			return;
-		}
-
-		increase_indent();
-
-		for (auto&& [k, v] : tbl)
-		{
-			if (!parent_is_array)
-			{
-				print_newline();
-				print_indent();
-			}
-			parent_is_array = false;
-
-			print_string(k.str(), false, true);
-			if (terse_kvps())
-				print_unformatted(":"sv);
-			else
-				print_unformatted(": "sv);
-
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print(*reinterpret_cast<const table*>(&v)); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v)); break;
-				case node_type::string: print_yaml_string(*reinterpret_cast<const value<std::string>*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-
-		decrease_indent();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void yaml_formatter::print(const toml::array& arr, bool parent_is_array)
-	{
-		if (arr.empty())
-		{
-			print_unformatted("[]"sv);
-			return;
-		}
-
-		increase_indent();
-
-		for (auto&& v : arr)
-		{
-			if (!parent_is_array)
-			{
-				print_newline();
-				print_indent();
-			}
-			parent_is_array = false;
-
-			print_unformatted("- "sv);
-
-			const auto type = v.type();
-			TOML_ASSUME(type != node_type::none);
-			switch (type)
-			{
-				case node_type::table: print(*reinterpret_cast<const table*>(&v), true); break;
-				case node_type::array: print(*reinterpret_cast<const array*>(&v), true); break;
-				case node_type::string: print_yaml_string(*reinterpret_cast<const value<std::string>*>(&v)); break;
-				default: print_value(v, type);
-			}
-		}
-
-		decrease_indent();
-	}
-
-	TOML_EXTERNAL_LINKAGE
-	void yaml_formatter::print()
-	{
-		if (dump_failed_parse_result())
-			return;
-
-		switch (auto source_type = source().type())
-		{
-			case node_type::table:
-				decrease_indent(); // so root kvps and tables have the same indent
-				print(*reinterpret_cast<const table*>(&source()));
-				break;
-
-			case node_type::array: print(*reinterpret_cast<const array*>(&source())); break;
-
-			case node_type::string: print_yaml_string(*reinterpret_cast<const value<std::string>*>(&source())); break;
-
-			default: print_value(source(), source_type);
-		}
-	}
-}
-TOML_NAMESPACE_END;
-
-#ifdef _MSC_VER
-#pragma pop_macro("min")
-#pragma pop_macro("max")
-#pragma inline_recursion(off)
-#endif
-TOML_POP_WARNINGS;
-
-#endif // TOML_ENABLE_FORMATTERS
-
-#endif // TOML_IMPLEMENTATION
-
-TOML_POP_WARNINGS;
-
-// macro hygiene
-#if TOML_UNDEF_MACROS
-#undef TOML_ABI_NAMESPACE_BOOL
-#undef TOML_ABI_NAMESPACE_END
-#undef TOML_ABI_NAMESPACE_START
-#undef TOML_ABI_NAMESPACES
-#undef TOML_ABSTRACT_INTERFACE
-#undef TOML_ALWAYS_INLINE
-#undef TOML_ANON_NAMESPACE
-#undef TOML_ANON_NAMESPACE_END
-#undef TOML_ANON_NAMESPACE_START
-#undef TOML_ARCH_AMD64
-#undef TOML_ARCH_ARM
-#undef TOML_ARCH_ARM32
-#undef TOML_ARCH_ARM64
-#undef TOML_ARCH_ITANIUM
-#undef TOML_ARCH_X86
-#undef TOML_ASSERT
-#undef TOML_ASSERT_ASSUME
-#undef TOML_ASSUME
-#undef TOML_ASYMMETRICAL_EQUALITY_OPS
-#undef TOML_ATTR
-#undef TOML_CLANG
-#undef TOML_CLOSED_ENUM
-#undef TOML_CLOSED_FLAGS_ENUM
-#undef TOML_COMPILER_HAS_EXCEPTIONS
-#undef TOML_COMPILER_HAS_RTTI
-#undef TOML_CONST
-#undef TOML_CONST_GETTER
-#undef TOML_CONST_INLINE_GETTER
-#undef TOML_CONSTRAINED_TEMPLATE
-#undef TOML_CPP
-#undef TOML_DECLSPEC
-#undef TOML_DELETE_DEFAULTS
-#undef TOML_DISABLE_ARITHMETIC_WARNINGS
-#undef TOML_DISABLE_CODE_ANALYSIS_WARNINGS
-#undef TOML_DISABLE_SPAM_WARNINGS
-#undef TOML_DISABLE_SPAM_WARNINGS_CLANG_10
-#undef TOML_DISABLE_SPAM_WARNINGS_CLANG_11
-#undef TOML_DISABLE_SUGGEST_ATTR_WARNINGS
-#undef TOML_DISABLE_SWITCH_WARNINGS
-#undef TOML_DISABLE_WARNINGS
-#undef TOML_DOXYGEN
-#undef TOML_EMPTY_BASES
-#undef TOML_ENABLE_IF
-#undef TOML_ENABLE_WARNINGS
-#undef TOML_EVAL_BOOL_0
-#undef TOML_EVAL_BOOL_1
-#undef TOML_EXTERNAL_LINKAGE
-#undef TOML_FLAGS_ENUM
-#undef TOML_FLOAT_CHARCONV
-#undef TOML_FLOAT128
-#undef TOML_FLOAT16_DIG
-#undef TOML_FLOAT16_LIMITS_SET
-#undef TOML_FLOAT16_MANT_DIG
-#undef TOML_FLOAT16_MAX_10_EXP
-#undef TOML_FLOAT16_MAX_EXP
-#undef TOML_FLOAT16_MIN_10_EXP
-#undef TOML_FLOAT16_MIN_EXP
-#undef TOML_GCC
-#undef TOML_HAS_ATTR
-#undef TOML_HAS_BUILTIN
-#undef TOML_HAS_CHAR8
-#undef TOML_HAS_CPP_ATTR
-#undef TOML_HAS_CUSTOM_OPTIONAL_TYPE
-#undef TOML_HAS_FEATURE
-#undef TOML_HAS_INCLUDE
-#undef TOML_HAS_SSE2
-#undef TOML_HAS_SSE4_1
-#undef TOML_HIDDEN_CONSTRAINT
-#undef TOML_ICC
-#undef TOML_ICC_CL
-#undef TOML_IMPL_NAMESPACE_END
-#undef TOML_IMPL_NAMESPACE_START
-#undef TOML_IMPLEMENTATION
-#undef TOML_INCLUDE_WINDOWS_H
-#undef TOML_INT_CHARCONV
-#undef TOML_INT128
-#undef TOML_INTELLISENSE
-#undef TOML_INTERNAL_LINKAGE
-#undef TOML_LANG_AT_LEAST
-#undef TOML_LANG_EFFECTIVE_VERSION
-#undef TOML_LANG_HIGHER_THAN
-#undef TOML_LANG_UNRELEASED
-#undef TOML_LAUNDER
-#undef TOML_LIFETIME_HOOKS
-#undef TOML_LIKELY
-#undef TOML_LIKELY_CASE
-#undef TOML_MAKE_FLAGS
-#undef TOML_MAKE_FLAGS_
-#undef TOML_MAKE_FLAGS_1
-#undef TOML_MAKE_FLAGS_2
-#undef TOML_MAKE_STRING
-#undef TOML_MAKE_STRING_1
-#undef TOML_MAKE_VERSION
-#undef TOML_MSVC
-#undef TOML_NAMESPACE
-#undef TOML_NEVER_INLINE
-#undef TOML_NODISCARD
-#undef TOML_NODISCARD_CTOR
-#undef TOML_OPEN_ENUM
-#undef TOML_OPEN_FLAGS_ENUM
-#undef TOML_PARSER_TYPENAME
-#undef TOML_POP_WARNINGS
-#undef TOML_PRAGMA_CLANG
-#undef TOML_PRAGMA_CLANG_GE_10
-#undef TOML_PRAGMA_CLANG_GE_11
-#undef TOML_PRAGMA_CLANG_GE_9
-#undef TOML_PRAGMA_GCC
-#undef TOML_PRAGMA_ICC
-#undef TOML_PRAGMA_MSVC
-#undef TOML_PURE
-#undef TOML_PURE_GETTER
-#undef TOML_PURE_INLINE_GETTER
-#undef TOML_PUSH_WARNINGS
-#undef TOML_REQUIRES
-#undef TOML_SA_LIST_BEG
-#undef TOML_SA_LIST_END
-#undef TOML_SA_LIST_NEW
-#undef TOML_SA_LIST_NXT
-#undef TOML_SA_LIST_SEP
-#undef TOML_SA_NATIVE_VALUE_TYPE_LIST
-#undef TOML_SA_NEWLINE
-#undef TOML_SA_NODE_TYPE_LIST
-#undef TOML_SA_UNWRAPPED_NODE_TYPE_LIST
-#undef TOML_SA_VALUE_EXACT_FUNC_MESSAGE
-#undef TOML_SA_VALUE_FUNC_MESSAGE
-#undef TOML_SA_VALUE_MESSAGE_CONST_CHAR8
-#undef TOML_SA_VALUE_MESSAGE_U8STRING_VIEW
-#undef TOML_SA_VALUE_MESSAGE_WSTRING
-#undef TOML_SIMPLE_STATIC_ASSERT_MESSAGES
-#undef TOML_TRIVIAL_ABI
-#undef TOML_UINT128
-#undef TOML_UNLIKELY
-#undef TOML_UNLIKELY_CASE
-#undef TOML_UNREACHABLE
-#undef TOML_UNUSED
-#undef TOML_WINDOWS
-#endif
-
-#endif // TOMLPLUSPLUS_H
diff --git a/keybinds.cpp b/keybinds.cpp
new file mode 100644
index 0000000..57f7003
--- /dev/null
+++ b/keybinds.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+
+#include "keybinds.h"
+
+using std::string, std::cin, std::cout, std::endl;
+
+KeybindsModule::KeybindsModule(CommandsModule& commandsModule)
+	:commandsModule(commandsModule)
+{
+	CommandArgType* bindArgs = new CommandArgType[2];
+	bindArgs[0] = STR;
+	bindArgs[1] = STR_REST;
+	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, bindArgs, this);
+	commandsModule.addCommand("exit", &KeybindsModule::exit, 0, {}, this);
+	commandsModule.addCommand("readBinds", &KeybindsModule::readBinds, 0, {}, this);
+	exitNow = false;
+}
+
+const void KeybindsModule::bind(const CommandArg* argv)
+{
+	Err e = commandsModule.checkCommand(argv[1].str);
+	if(e.code != NOERR)
+	{
+		e.message = "Binding fail - " + e.message;
+		throw e;
+	}
+	binds.insert({argv[0].str, argv[1].str});
+}
+const void KeybindsModule::readBinds(const CommandArg* argv)
+{
+	cout << "Reading binds" << endl;
+	while(exitNow == false)
+	{
+		string key;
+		cout << "> ";
+		std::getline(std::cin, key);
+		commandsModule.runCommand(binds.find(key)->second);
+	}
+}
+
+const void KeybindsModule::exit(const CommandArg* argv)
+{
+	exitNow = true;
+	cout << "Exiting..." << endl;
+}
diff --git a/keybinds.h b/keybinds.h
new file mode 100644
index 0000000..d26b7a1
--- /dev/null
+++ b/keybinds.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <unordered_map>
+#include <string>
+
+#include "commands.h"
+
+class KeybindsModule {
+	public:
+		KeybindsModule(CommandsModule& commandsModule);
+		~KeybindsModule() = default;
+		const void bind(const CommandArg* argv);
+		const void readBinds(const CommandArg* argv);
+		const void exit(const CommandArg* argv);
+	private:
+		std::unordered_map<std::string, std::string> binds;
+		bool exitNow;
+		CommandsModule& commandsModule;
+};
diff --git a/main.cpp b/main.cpp
index d367ead..1433e70 100644
--- a/main.cpp
+++ b/main.cpp
@@ -4,7 +4,6 @@
 #include <X11/cursorfont.h>
 
 #include <libnotify/notification.h>
-#include <toml++/toml.hpp>
 
 #include <libnotify/notify.h>
 
@@ -26,10 +25,12 @@
 #include <algorithm>
 #include <fcntl.h>
 
+#include "commands.h"
 #include "structs.h"
 #include "config.h"
 #include "util.h"
 #include "ewmh.h"
+#include "error.h"
 
 using std::cout;
 using std::string;
@@ -42,7 +43,8 @@ std::ofstream yatlog;
 
 #define log(x) yatlog << x << std::endl
 
-Config cfg;
+CommandsModule commandsModule;
+Config cfg(commandsModule);
 
 Display* dpy;
 Window root;
@@ -194,11 +196,11 @@ void handleConfigErrs(Err cfgErr)
 }
 
 //Keybind commands
-void exit(const KeyArg arg)
+const void exit(const CommandArg* argv)
 {
 	keepGoing = false;
 }
-void spawn(const KeyArg arg)
+const void spawn(const CommandArg* argv)
 {
 	if(fork() == 0)
 	{
@@ -206,7 +208,7 @@ void spawn(const KeyArg arg)
 		dup2(null, 0);
 		dup2(null, 1);
 		dup2(null, 2);
-		const std::string argsStr = arg.str;
+		const std::string argsStr = argv[0].str;
 		vector<std::string> args = split(argsStr, ' ');
 		char** execvpArgs = new char*[args.size()];
 		for(int i = 0; i < args.size(); i++)
@@ -217,11 +219,11 @@ void spawn(const KeyArg arg)
 		exit(0);
 	}
 }
-void toggle(const KeyArg arg)
+const void toggle(const CommandArg* argv)
 {
 	nextDir = nextDir = (nextDir==horizontal)? vertical : horizontal;
 }
-void kill(const KeyArg arg)
+const void kill(const CommandArg* argv)
 {
 	Window w;
 	int revertToReturn;
@@ -252,11 +254,11 @@ void kill(const KeyArg arg)
       XKillClient(dpy, w);
     }
 }
-void changeWS(const KeyArg arg)
+const void changeWS(const CommandArg* argv)
 {
 	int prevWS = currWS;
 
-	currWS = arg.num;
+	currWS = argv[0].num;
 	if(prevWS == currWS)
 		return;
 	untileRoots();
@@ -265,17 +267,17 @@ void changeWS(const KeyArg arg)
 
 	for(int i = 0; i < cfg.maxMonitors; i++)
 	{
-		if(nscreens > cfg.screenPreferences[arg.num - 1][i])
+		if(nscreens > cfg.screenPreferences[argv[0].num - 1][i])
 		{
-			int screen = cfg.screenPreferences[arg.num - 1][i];
+			int screen = cfg.screenPreferences[argv[0].num - 1][i];
 			//log("Found screen (screen " << screenPreferences[arg.num - 1][i] << ")");
-			prevWS = focusedWorkspaces[cfg.screenPreferences[arg.num - 1][i]];
+			prevWS = focusedWorkspaces[cfg.screenPreferences[argv[0].num - 1][i]];
 			//log("Changed prevWS");
-			focusedWorkspaces[cfg.screenPreferences[arg.num - 1][i]] = arg.num;
+			focusedWorkspaces[cfg.screenPreferences[argv[0].num - 1][i]] = argv[0].num;
 			//log("Changed focusedWorkspaces");
-			if(focusedScreen != cfg.screenPreferences[arg.num - 1][i])
+			if(focusedScreen != cfg.screenPreferences[argv[0].num - 1][i])
 			{
-				focusedScreen = cfg.screenPreferences[arg.num - 1][i];
+				focusedScreen = cfg.screenPreferences[argv[0].num - 1][i];
 				XWarpPointer(dpy, root, root, 0, 0, 0, 0, screens[screen].x + screens[screen].w/2, screens[screen].y + screens[screen].h/2);
 			}
 			//log("Changed focusedScreen");
@@ -299,7 +301,7 @@ void changeWS(const KeyArg arg)
 	//EWMH
 	setCurrentDesktop(currWS);
 }
-void wToWS(const KeyArg arg)
+const void wToWS(const CommandArg* argv)
 {
 	Window focusedWindow;
 	int revertToReturn;
@@ -340,11 +342,11 @@ void wToWS(const KeyArg arg)
 			break;
 		}
 	}
-	frames.find(fID)->second.pID = arg.num;
-	frames.find(arg.num)->second.subFrameIDs.push_back(fID);
+	frames.find(fID)->second.pID = argv[0].num;
+	frames.find(argv[0].num)->second.subFrameIDs.push_back(fID);
 
 	//EWMH
-	setWindowDesktop(focusedWindow, arg.num);
+	setWindowDesktop(focusedWindow, argv[0].num);
 
 	XUnmapWindow(dpy, focusedWindow);
 	//tile(currWS, outerGaps, outerGaps, sW - outerGaps*2, sH - outerGaps*2 - bH);
@@ -371,20 +373,20 @@ int dirFind(int fID, MoveDir dir)
 	{
 		switch(dir)
 		{
-			case Up: i--; break;
-			case Down: i++; break;
-			case Left: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
-			case Right: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
+			case UP: i--; break;
+			case DOWN: i++; break;
+			case LEFT: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
+			case RIGHT: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
 		}
 	}
 	else if(pDir == horizontal)
 	{
 		switch(dir)
 		{
-			case Left: i--; break;
-			case Right: i++; break;
-			case Up: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
-			case Down: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
+			case LEFT: i--; break;
+			case RIGHT: i++; break;
+			case UP: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
+			case DOWN: return (frames.find(fID)->second.pID > cfg.numWS)? dirFind(frames.find(fID)->second.pID, dir) : fID;
 		}
 	}
 	if(i < 0)
@@ -394,7 +396,7 @@ int dirFind(int fID, MoveDir dir)
 
 	return pSF[i];
 }
-void focChange(const KeyArg arg)
+const void focChange(const CommandArg* argv)
 {
 	Window focusedWindow;
 	int revertToReturn;
@@ -403,12 +405,12 @@ void focChange(const KeyArg arg)
 		return;
 
 	int fID = frameIDS.find(focusedWindow)->second;
-	int nID = dirFind(fID, arg.dir);
+	int nID = dirFind(fID, argv[0].dir);
 	int fNID = FFCF(nID);
 	Window w = clients.find(frames.find(fNID)->second.cID)->second.w;
 	XSetInputFocus(dpy, w, RevertToPointerRoot, CurrentTime);
 }
-void wMove(const KeyArg arg)
+const void wMove(const CommandArg* argv)
 {
 	Window focusedWindow;
 	int revertToReturn;
@@ -419,7 +421,7 @@ void wMove(const KeyArg arg)
 	int fID = frameIDS.find(focusedWindow)->second;
 	if(clients.find(frames.find(fID)->second.cID)->second.floating)
 		return;
-	int nID = dirFind(fID, arg.dir);
+	int nID = dirFind(fID, argv[0].dir);
 	int fNID = FFCF(nID);
 	int pID = frames.find(fNID)->second.pID;
 	int oPID = frames.find(fID)->second.pID;
@@ -461,17 +463,17 @@ void wMove(const KeyArg arg)
 		{
 			if(frames.find(pID)->second.dir == vertical)
 			{
-				if(arg.dir == Left || arg.dir == Right)
+				if(argv[0].dir == LEFT || argv[0].dir == RIGHT)
 					return;
 			}
 			else
 			{
-				if(arg.dir == Up || arg.dir == Down)
+				if(argv[0].dir == UP || argv[0].dir == DOWN)
 					return;
 			}
 					
 			int offset;
-			if(arg.dir == Up || arg.dir == Left)
+			if(argv[0].dir == UP || argv[0].dir == LEFT)
 				offset = -1;
 			else
 				offset = 1;
@@ -493,7 +495,7 @@ void wMove(const KeyArg arg)
 	}
 	XSetInputFocus(dpy, focusedWindow, RevertToPointerRoot, CurrentTime);
 }
-void bashSpawn(const KeyArg arg)
+const void bashSpawn(const CommandArg* argv)
 {
 	if(fork() == 0)
 	{
@@ -501,12 +503,12 @@ void bashSpawn(const KeyArg arg)
 		dup2(null, 0);
 		dup2(null, 1);
 		dup2(null, 2);
-		system(arg.str);
+		system(argv[0].str);
 		exit(0);
 	}
 
 }
-void reload(const KeyArg arg)
+const void reload(const CommandArg* argv)
 {
 	detectScreens();
 
@@ -518,7 +520,7 @@ void reload(const KeyArg arg)
 	//Re tile
 	tileRoots();
 }
-void wsDump(const KeyArg arg)
+const void wsDump(const CommandArg* argv)
 {
 	log("Workspace dump:");
 	for(int i = 1; i < currFrameID; i++)
@@ -534,7 +536,7 @@ void wsDump(const KeyArg arg)
 		}
 	}
 }
-void nextMonitor(const KeyArg arg)
+const void nextMonitor(const CommandArg* argv)
 {
 	focusedScreen++;
 	if(focusedScreen >= nscreens)
diff --git a/makefile b/makefile
index 5d15556..01e6b5d 100644
--- a/makefile
+++ b/makefile
@@ -1,6 +1,6 @@
 .PHONY: clean
 CXX := g++
-CXXFLAGS := -std=c++17 -Iinclude `pkg-config --cflags --libs libnotify`# -g -fsanitize=address -fno-omit-frame-pointer
+CXXFLAGS := -std=c++17 `pkg-config --cflags --libs libnotify`# -g -fsanitize=address -fno-omit-frame-pointer
 LINKFLAGS := -lX11 -lXrandr
 OBJS_DIR := .
 OUT_DIR := .
@@ -32,7 +32,9 @@ remove: r
 $(OBJS_DIR)/main.o: $(SOURCE_FILES) $(SOURCE_HEADERS)
 $(OBJS_DIR)/ewmh.o: $(SOURCE_DIR)/ewmh.cpp $(SOURCE_DIR)/ewmh.h
 $(OBJS_DIR)/util.o: $(SOURCE_DIR)/util.cpp $(SOURCE_DIR)/util.h
-$(OBJS_DIR)/config.o: $(SOURCE_DIR)/config.cpp $(SOURCE_DIR)/config.h $(OBJS_DIR)/util.o
+$(OBJS_DIR)/commands.o: $(SOURCE_DIR)/commands.cpp $(SOURCE_DIR)/commands.h
+$(OBJS_DIR)/config.o: $(SOURCE_DIR)/config.cpp $(SOURCE_DIR)/config.h
+$(OBJS_DIR)/keybinds.o: $(SOURCE_DIR)/keybinds.cpp $(SOURCE_DIR)/keybinds.h $(SOURCE_DIR)/commands.h
 
 clean:
 	rm $(OBJS_DIR)/*.o 
diff --git a/old.config.cpp b/old.config.cpp
new file mode 100644
index 0000000..74ba0b0
--- /dev/null
+++ b/old.config.cpp
@@ -0,0 +1,364 @@
+#include "config.h"
+
+#include "error.h"
+#include "toml++/toml.hpp"
+#include "util.h"
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+
+#include <string>
+#include <map>
+
+//Just for testing
+#include <iostream>
+#include <vector>
+
+using std::map, std::string, std::to_string;
+
+// For testing
+using std::cout, std::endl, std::cerr;
+
+map<string, void(*) (const KeyArg arg)> funcNameMap = {
+	{"exit", exit},
+	{"spawn", spawn},
+	{"toggle", toggle},
+	{"kill", kill},
+	{"changeWS", changeWS},
+	{"wToWS", wToWS},
+	{"focChange", focChange},
+	{"wMove", wMove},
+	{"bashSpawn", bashSpawn},
+	{"reload", reload},
+	{"wsDump", wsDump},
+	{"nextMonitor", nextMonitor},
+};
+
+
+Config::Config()
+{
+}
+
+string to_string(string s)
+{
+	return s;
+}
+string to_string(bool b)
+{
+	if(b)
+		return "true";
+	else
+		return "false";
+}
+
+template <typename T>
+T Config::getValue(string path, Err* err)
+{
+	std::optional<T> tblVal = tbl.at_path(path).value<T>();
+	if(tblVal)
+		return *tblVal;
+	else
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		T val = *defaults.at_path(path).value<T>();
+		err->errorMessage += "\n\tValue for " + path + " is invalid, using default (" + to_string(val) + ")";
+		return val;
+	}
+}
+
+void Config::loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err)
+{
+	if(!tbl["Workspaces"]["workspaceNames"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\n\tworkspaceNames invalid array, using defaults";
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	workspaceNamesc = tbl["Workspaces"]["workspaceNames"].as_array()->size();
+	workspaceNames = new string[workspaceNamesc];
+	for(int i = 0; i < workspaceNamesc; i++)
+	{
+		auto element = tbl["Workspaces"]["workspaceNames"][i].value<string>();
+		if(element)
+			workspaceNames[i] = *element;
+		else
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\nelement " + to_string(i) + " in workspaceNames invalid, using defaults";
+			delete[] workspaceNames;
+			return loadWorkspaceArrays(defaults, defaults, err);
+		}
+	}
+	if(!tbl["Workspaces"]["screenPreferences"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\nscreenPreferences invalid array, using default";
+		delete[] workspaceNames;
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	screenPreferencesc = tbl["Workspaces"]["screenPreferences"].as_array()->size();
+	if(screenPreferencesc != workspaceNamesc)
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\nworkspaceNames and screenPreferences aren't the same length, using defaults";
+		delete[] workspaceNames;
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	screenPreferences = new int*[screenPreferencesc];
+	for(int i = 0; i < screenPreferencesc; i++)
+	{
+		if(!tbl["Workspaces"]["screenPreferences"][i].as_array())
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\telement " + to_string(i) + " in screenPreferences in invalid, using defaults";
+			delete[] workspaceNames;
+			for(int k = 0; k < i; k++)
+			{
+				delete[] screenPreferences[k];
+			}
+			delete[] screenPreferences;
+			return loadWorkspaceArrays(defaults, defaults, err);
+		}
+		int* wsScreens = new int[maxMonitors];
+		for(int j = 0; j < maxMonitors; j++)
+		{
+			if(tbl["Workspaces"]["screenPreferences"][i].as_array()->size() <= j)
+			{
+				wsScreens[j] = 0;
+				continue;
+			}
+			auto element = tbl["Workspaces"]["screenPreferences"][i][j].value<int>();
+			if(element)
+				wsScreens[j] = *element;
+			else
+			{
+				err->code = ERR_CFG_NON_FATAL;
+				err->errorMessage += "\telement " + to_string(i) + " " + to_string(j) + " in screenPreferences in invalid, using defaults";
+				delete[] workspaceNames;
+				for(int k = 0; k <= i; k++)
+				{
+					delete[] screenPreferences[k];
+				}
+				delete[] screenPreferences;
+				return loadWorkspaceArrays(defaults, defaults, err);
+			}
+		}
+		screenPreferences[i] = wsScreens;
+	}
+}
+
+void Config::loadStartupBash(toml::table tbl, toml::table defaults, Err* err)
+{
+	if(!tbl["Startup"]["startupBash"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\n\tstartupBash array invalid, using default";
+		return loadStartupBash(defaults, defaults, err);
+	}
+	startupBashc = tbl["Startup"]["startupBash"].as_array()->size();
+	std::vector<string> startupBash;
+	for(int i = 0; i < startupBashc; i++)
+	{
+		auto element = tbl["Startup"]["startupBash"][i].value<string>();
+		if(element)
+			startupBash.push_back(*element);
+		else
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\n\tstartupBash element " + to_string(i) + " invalid, skipping";
+		}
+	}
+	startupBashc = startupBash.size();
+	this->startupBash = new string[startupBashc];
+	for(int i = 0; i < startupBash.size(); i++)
+	{
+		this->startupBash[i] = startupBash[i];
+	}
+}
+
+Err Config::reload()
+{
+	if(!loaded)
+		return {ERR_CFG_FATAL, "Path not set yet, call loadFromFile before reload"};
+	return loadFromFile(path);
+}
+
+Err Config::loadFromFile(string path)
+{
+	if(loaded)
+	{
+		free();
+	}
+	loaded = true;
+	this->path = path;
+	Err err;
+	err.code = NOERR;
+	err.errorMessage = "";
+	defaults = toml::parse_file("/etc/YATwm/config.toml");
+	try
+	{
+		tbl = toml::parse_file(path);
+	}
+	catch (const toml::parse_error& parseErr)
+	{
+		err.code = ERR_CFG_FATAL;
+		string description = (string) parseErr.description();
+		string startCol = std::to_string(parseErr.source().begin.column);
+		string startLine = std::to_string(parseErr.source().begin.line);
+		string endCol = std::to_string(parseErr.source().end.column);
+		string endLine = std::to_string(parseErr.source().end.line);
+		string pos =  "Line " + startLine;
+		string what = parseErr.what();
+		err.errorMessage += "\n\t" + description + "\t(" + pos + ")" + "\n\tUsing /etc/YATwm/config.toml instead";
+		tbl = defaults;
+	}
+
+	//Startup
+	loadStartupBash(tbl, defaults, &err);
+
+	//Main
+	gaps = getValue<int>("Main.gaps", &err);
+	outerGaps = getValue<int>("Main.outerGaps", &err);
+	logFile = getValue<string>("Main.logFile", &err);
+
+	//Workspaces
+	numWS = getValue<int>("Workspaces.numWS", &err);
+	maxMonitors = getValue<int>("Workspaces.maxMonitors", &err);
+	loadWorkspaceArrays(tbl, defaults, &err);
+	
+	//Keybinds
+	bool swapSuperAlt = getValue<bool>("Keybinds.swapSuperAlt", &err);
+
+	toml::node_view<toml::node> bindsArr = tbl["Keybinds"]["key"];
+	if(!bindsArr.is_array())
+	{
+		err.code = ERR_CFG_NON_FATAL;
+		err.errorMessage += "\n\tBinds array not valid, using default";
+		bindsArr = defaults["Keybinds"]["key"];
+	}
+	std::vector<KeyBind> keyBinds;
+	bindsc = bindsArr.as_array()->size();
+	for(int i = 0; i < bindsc; i++)
+	{
+		KeyBind bind;
+		bind.modifiers = 0;
+		const std::optional<string> potentialBindString = bindsArr[i]["bind"].value<string>();
+		string bindString;
+		if(potentialBindString)
+			bindString = *potentialBindString;
+		else
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
+			continue;
+		}
+		std::vector<string> keys = split(bindString, '+');
+		for(string key : keys)
+		{
+			if(key == "mod")
+			{
+				if(!swapSuperAlt)
+					bind.modifiers |= Mod4Mask;
+				else
+					bind.modifiers |= Mod1Mask;
+			}
+			else if(key == "alt")
+			{
+				if(swapSuperAlt)
+					bind.modifiers |= Mod4Mask;
+				else
+					bind.modifiers |= Mod1Mask;
+			}
+			else if(key == "shift")
+			{
+				bind.modifiers |= ShiftMask;
+			}
+			else if(key == "control")
+			{
+				bind.modifiers |= ControlMask;
+			}
+			else
+			{
+				bind.keysym = XStringToKeysym(key.c_str());
+				if(bind.keysym == NoSymbol)
+				{
+					err.code = ERR_CFG_NON_FATAL;
+					err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
+					continue;
+				}
+			}
+		}
+		std::optional<string> potentialFuncString = bindsArr[i]["func"].value<string>();
+		string funcString;
+		if(potentialFuncString)
+			funcString = *potentialFuncString;
+		else
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
+			continue;
+		}
+		if(funcNameMap.count(funcString) == 0)
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
+			continue;
+		}
+		void(* func) (const KeyArg arg) = funcNameMap.find(funcString)->second;
+		bind.func = func;
+
+		auto args = bindsArr[i]["args"];
+		if(args.is<int64_t>())
+		{
+			int num = *args.value<int>();
+			bind.args = {.num = num};
+		}
+		else if(args.is<string>())
+		{
+			string str = (string)*args.value<string>();
+			if(str == "Up")
+				bind.args = {.dir = Up};
+			else if (str == "Down")
+				bind.args = {.dir = Down};
+			else if (str == "Left")
+				bind.args = {.dir = Left};
+			else if (str == "Right")
+				bind.args = {.dir = Right};
+			else
+			{
+				bind.args = {.str = strdup(str.c_str())};
+			}
+		}
+		else
+		{
+			bind.args = {NULL};
+		}
+		keyBinds.push_back(bind);
+	}
+	bindsc = keyBinds.size();
+	binds = new KeyBind[bindsc];
+	for(int i = 0; i < bindsc; i++)
+	{
+		binds[i] = keyBinds[i];
+	}
+	if(err.code != NOERR)
+		err.errorMessage = err.errorMessage.substr(1);
+	return err;
+}
+
+Config::~Config()
+{
+	free();
+}
+void Config::free()
+{
+	delete[] startupBash;
+	delete[] workspaceNames;
+	for(int i = 0; i < screenPreferencesc; i++)
+	{
+		delete[] screenPreferences[i];
+	}
+	delete[] screenPreferences;
+	delete[] binds;
+	loaded = false;
+}
diff --git a/old.config.h b/old.config.h
new file mode 100644
index 0000000..31005e7
--- /dev/null
+++ b/old.config.h
@@ -0,0 +1,93 @@
+#pragma once
+
+#include "error.h"
+
+#include <toml++/toml.hpp>
+
+#include <X11/X.h>
+#include <X11/keysym.h>
+
+#include <string>
+
+enum MoveDir
+{
+	Up,
+	Right,
+	Down,
+	Left
+};
+
+typedef union
+{
+	char* str;
+	int num;
+	MoveDir dir;
+} KeyArg;
+
+struct KeyBind
+{
+	unsigned int modifiers;
+	KeySym keysym;
+	void(* func) (const KeyArg arg);
+	KeyArg args;
+};
+
+//Keybind commands
+#define KEYCOM(X) \
+	void X (const KeyArg arg)
+KEYCOM(exit);
+KEYCOM(spawn);
+KEYCOM(toggle);
+KEYCOM(kill);
+KEYCOM(changeWS);
+KEYCOM(wToWS);
+KEYCOM(focChange);
+KEYCOM(wMove);
+KEYCOM(bashSpawn);
+KEYCOM(reload);
+KEYCOM(wsDump);
+KEYCOM(nextMonitor);
+
+class Config
+{   
+	public:
+		Config();
+		~Config();
+		void free();
+	
+		Err loadFromFile(std::string path);
+		Err reload();
+
+		// Startup
+		std::string* startupBash;
+		int startupBashc;
+
+		// Main
+		int gaps;
+		int outerGaps;
+		std::string logFile;
+
+		// Workspaces
+		int numWS;
+		std::string* workspaceNames;
+		int workspaceNamesc;
+		int maxMonitors;
+		int** screenPreferences;
+		int screenPreferencesc;
+
+		// Keybinds
+		KeyBind* binds;
+		int bindsc;
+	private:
+		template <typename T>
+		T getValue(std::string path, Err* err);
+
+		void loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err);
+		void loadStartupBash(toml::table tbl, toml::table defaults, Err* err);
+
+		toml::table tbl;
+		toml::table defaults;
+
+		bool loaded = false;
+		std::string path;
+};
-- 
cgit v1.2.3


From 27137ec9d29c36df8117869773203b243849896c Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Fri, 26 May 2023 21:46:19 +1200
Subject: feat: Made keybinds work (I hope)

Note: the config file reloading keybinds isn't quite working, though, need to ungrab the keys
---
 commands.cpp |  2 +-
 commands.h   |  2 +-
 config.cpp   | 11 ++++++----
 config.h     |  4 ++--
 error.h      |  7 ++++++-
 keybinds.cpp | 66 ++++++++++++++++++++++++++++++++++++++++++++++++------------
 keybinds.h   | 34 +++++++++++++++++++++----------
 main.cpp     | 64 +++++++++++++++++++++++-----------------------------------
 8 files changed, 118 insertions(+), 72 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index 3e78463..322d160 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -104,7 +104,7 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 		{
 			case STR: args[i-1].str = (char*)split[i].c_str(); break;
 			case NUM: args[i-1].num = std::stoi(split[i]); break;
-			case DIR: args[i-1].dir = LEFT; break;
+			case MOVDIR: args[i-1].dir = LEFT; break;
 			case STR_REST:
 			{
 				string rest = "";
diff --git a/commands.h b/commands.h
index f9a0999..2e364ac 100644
--- a/commands.h
+++ b/commands.h
@@ -18,7 +18,7 @@ enum CommandArgType
 {
 	STR,
 	NUM,
-	DIR,
+	MOVDIR,
 	STR_REST,
 	NUM_ARR_REST
 };
diff --git a/config.cpp b/config.cpp
index 101af24..6d8215c 100644
--- a/config.cpp
+++ b/config.cpp
@@ -1,5 +1,6 @@
 #include "config.h"
 #include "commands.h"
+#include "error.h"
 
 #include <X11/Xlib.h>
 
@@ -66,6 +67,7 @@ const void Config::focChange(const CommandArg* argv)
 }
 const void Config::reload(const CommandArg* argv)
 {
+	// Note: this is kinda broken cos it doesn't ungrab keys, i'll do that later.
 	cout << "Reloading config" << endl;
 	reloadFile();
 }
@@ -116,14 +118,14 @@ Config::Config(CommandsModule& commandsModule)
 	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, addWorkspaceArgs, this);
 }
 
-void Config::reloadFile()
+Err Config::reloadFile()
 {
 	if(!loaded)
-		return;
-	loadFromFile(file);
+		return {CFG_ERR_NON_FATAL, "Not loaded config yet"};
+	return loadFromFile(file);
 }
 
-void Config::loadFromFile(string path)
+Err Config::loadFromFile(string path)
 {
 	file = path;
 	//Set defaults
@@ -152,6 +154,7 @@ void Config::loadFromFile(string path)
 		line++;
 	}
 	loaded = true;
+	return {NOERR, ""};
 }
 
 Config::~Config()
diff --git a/config.h b/config.h
index 3956492..a31c1df 100644
--- a/config.h
+++ b/config.h
@@ -23,8 +23,8 @@ class Config
 		~Config();
 		void free();
 	
-		void loadFromFile(std::string path);
-		void reloadFile();
+		Err loadFromFile(std::string path);
+		Err reloadFile();
 		// Startup
 		std::string* startupBash;
 		int startupBashc;
diff --git a/error.h b/error.h
index 630fc7f..f0a67a5 100644
--- a/error.h
+++ b/error.h
@@ -17,5 +17,10 @@ typedef unsigned int ErrCode;
 struct Err
 {
 	ErrCode code;
-	std::string errorMessage;
+	std::string message;
+	Err(ErrCode code, std::string message)
+	{
+		this->code = code;
+		this->message = message;
+	}
 };
diff --git a/keybinds.cpp b/keybinds.cpp
index 57f7003..ee6892a 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -1,21 +1,41 @@
+#include <X11/X.h>
+#include <X11/Xlib.h>
 #include <iostream>
+#include <sstream>
+#include <vector>
 
+#include "error.h"
 #include "keybinds.h"
+#include "util.h"
 
-using std::string, std::cin, std::cout, std::endl;
+using std::string, std::cout, std::endl;
 
-KeybindsModule::KeybindsModule(CommandsModule& commandsModule)
+KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Display* dpy, Window root)
 	:commandsModule(commandsModule)
 {
+	this->dpy = dpy;
+	this->root = root;
 	CommandArgType* bindArgs = new CommandArgType[2];
 	bindArgs[0] = STR;
 	bindArgs[1] = STR_REST;
 	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, bindArgs, this);
 	commandsModule.addCommand("exit", &KeybindsModule::exit, 0, {}, this);
-	commandsModule.addCommand("readBinds", &KeybindsModule::readBinds, 0, {}, this);
 	exitNow = false;
 }
 
+const void KeybindsModule::handleKeypress(XKeyEvent e)
+{
+	if(e.same_screen!=1) return;
+	//updateMousePos();
+	for(Keybind bind : binds)
+	{
+		if(bind.modifiers == e.state && bind.key == e.keycode)
+		{
+			commandsModule.runCommand(bind.command);
+		}
+	}
+}
+
 const void KeybindsModule::bind(const CommandArg* argv)
 {
 	Err e = commandsModule.checkCommand(argv[1].str);
@@ -24,18 +44,38 @@ const void KeybindsModule::bind(const CommandArg* argv)
 		e.message = "Binding fail - " + e.message;
 		throw e;
 	}
-	binds.insert({argv[0].str, argv[1].str});
-}
-const void KeybindsModule::readBinds(const CommandArg* argv)
-{
-	cout << "Reading binds" << endl;
-	while(exitNow == false)
+	std::vector<string> keys = split(argv[0].str, '+');
+	Keybind bind;
+	for(string key : keys)
 	{
-		string key;
-		cout << "> ";
-		std::getline(std::cin, key);
-		commandsModule.runCommand(binds.find(key)->second);
+		if(key == "mod")
+		{
+			bind.modifiers |= Mod1Mask;
+		}
+		else if(key == "alt")
+		{
+			bind.modifiers |= Mod1Mask;
+		}
+		else if(key == "shift")
+		{
+			bind.modifiers |= ShiftMask;
+		}
+		else if(key == "control")
+		{
+			bind.modifiers |= ControlMask;
+		}
+		else
+		{
+			bind.key = XKeysymToKeycode(dpy, XStringToKeysym(key.c_str()));
+			if(bind.key == NoSymbol)
+			{
+				throw Err(CFG_ERR_KEYBIND, "Keybind '" + string(argv[0].str) + "' is invalid!");
+				continue;
+			}
+		}
 	}
+	XGrabKey(dpy, bind.key, bind.modifiers, root, false, GrabModeAsync, GrabModeAsync);
+	binds.push_back(bind);
 }
 
 const void KeybindsModule::exit(const CommandArg* argv)
diff --git a/keybinds.h b/keybinds.h
index d26b7a1..c0cc955 100644
--- a/keybinds.h
+++ b/keybinds.h
@@ -1,19 +1,31 @@
 #pragma once
 
-#include <unordered_map>
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <map>
 #include <string>
+#include <X11/keysym.h>
+#include <vector>
 
 #include "commands.h"
 
+struct Keybind {
+	KeyCode key;
+	unsigned int modifiers;
+	std::string command;
+};
+
 class KeybindsModule {
-	public:
-		KeybindsModule(CommandsModule& commandsModule);
-		~KeybindsModule() = default;
-		const void bind(const CommandArg* argv);
-		const void readBinds(const CommandArg* argv);
-		const void exit(const CommandArg* argv);
-	private:
-		std::unordered_map<std::string, std::string> binds;
-		bool exitNow;
-		CommandsModule& commandsModule;
+public:
+	KeybindsModule(CommandsModule& commandsModule, Display* dpy, Window root);
+	~KeybindsModule() = default;
+	const void bind(const CommandArg* argv);
+	const void exit(const CommandArg* argv);
+	const void handleKeypress(XKeyEvent e);
+private:
+	std::vector<Keybind> binds;
+	bool exitNow;
+	CommandsModule& commandsModule;
+	Display* dpy;
+	Window root;
 };
diff --git a/main.cpp b/main.cpp
index 1433e70..e4a4bcc 100644
--- a/main.cpp
+++ b/main.cpp
@@ -26,6 +26,7 @@
 #include <fcntl.h>
 
 #include "commands.h"
+#include "keybinds.h"
 #include "structs.h"
 #include "config.h"
 #include "util.h"
@@ -43,11 +44,13 @@ std::ofstream yatlog;
 
 #define log(x) yatlog << x << std::endl
 
+Display* dpy;
+Window root;
+
 CommandsModule commandsModule;
 Config cfg(commandsModule);
+KeybindsModule keybindsModule(commandsModule, dpy, root);
 
-Display* dpy;
-Window root;
 int sW, sH;
 int bH;
 TileDir nextDir = horizontal;
@@ -81,7 +84,6 @@ void updateMousePos();
 void focusRoot(int root);
 void handleConfigErrs(Err cfgErr);
 
-void keyPress(XKeyEvent e);
 void configureRequest(XConfigureRequestEvent e);
 void mapRequest(XMapRequestEvent e);
 void destroyNotify(XDestroyWindowEvent e);
@@ -164,11 +166,11 @@ void handleConfigErrs(Err cfgErr)
 {
 	if(cfgErr.code!=NOERR)
 	{
-		if(cfgErr.code == ERR_CFG_FATAL)
+		if(cfgErr.code == CFG_ERR_FATAL)
 		{
-			log("YATwm fatal error (Code " << cfgErr.code << ")\n" << cfgErr.errorMessage);
+			log("YATwm fatal error (Code " << cfgErr.code << ")\n" << cfgErr.message);
 			std::string title = "YATwm fatal config error (Code " + std::to_string(cfgErr.code) + ")";
-			std::string body = cfgErr.errorMessage;
+			std::string body = cfgErr.message;
 			NotifyNotification* n = notify_notification_new(title.c_str(),
 															body.c_str(),
 															0);
@@ -180,7 +182,7 @@ void handleConfigErrs(Err cfgErr)
 		}
 		else
 		{
-			log("YATwm non fatal error (Code " << cfgErr.code << ")\n" << cfgErr.errorMessage);
+			log("YATwm non fatal error (Code " << cfgErr.code << ")\n" << cfgErr.message);
 			std::string title = "YATwm non fatal config error (Code " + std::to_string(cfgErr.code) + ")";
 			std::string body = "Check logs for more information";
 			NotifyNotification* n = notify_notification_new(title.c_str(),
@@ -254,11 +256,12 @@ const void kill(const CommandArg* argv)
       XKillClient(dpy, w);
     }
 }
-const void changeWS(const CommandArg* argv)
+// Took this out as it is used commonly
+void cWS(int newWS)
 {
 	int prevWS = currWS;
 
-	currWS = argv[0].num;
+	currWS = newWS;
 	if(prevWS == currWS)
 		return;
 	untileRoots();
@@ -267,17 +270,17 @@ const void changeWS(const CommandArg* argv)
 
 	for(int i = 0; i < cfg.maxMonitors; i++)
 	{
-		if(nscreens > cfg.screenPreferences[argv[0].num - 1][i])
+		if(nscreens > cfg.screenPreferences[newWS - 1][i])
 		{
-			int screen = cfg.screenPreferences[argv[0].num - 1][i];
+			int screen = cfg.screenPreferences[newWS - 1][i];
 			//log("Found screen (screen " << screenPreferences[arg.num - 1][i] << ")");
-			prevWS = focusedWorkspaces[cfg.screenPreferences[argv[0].num - 1][i]];
+			prevWS = focusedWorkspaces[cfg.screenPreferences[newWS - 1][i]];
 			//log("Changed prevWS");
-			focusedWorkspaces[cfg.screenPreferences[argv[0].num - 1][i]] = argv[0].num;
+			focusedWorkspaces[cfg.screenPreferences[newWS - 1][i]] = newWS;
 			//log("Changed focusedWorkspaces");
-			if(focusedScreen != cfg.screenPreferences[argv[0].num - 1][i])
+			if(focusedScreen != cfg.screenPreferences[newWS - 1][i])
 			{
-				focusedScreen = cfg.screenPreferences[argv[0].num - 1][i];
+				focusedScreen = cfg.screenPreferences[newWS - 1][i];
 				XWarpPointer(dpy, root, root, 0, 0, 0, 0, screens[screen].x + screens[screen].w/2, screens[screen].y + screens[screen].h/2);
 			}
 			//log("Changed focusedScreen");
@@ -301,6 +304,10 @@ const void changeWS(const CommandArg* argv)
 	//EWMH
 	setCurrentDesktop(currWS);
 }
+const void changeWS(const CommandArg* argv)
+{
+	cWS(argv[0].num);
+}
 const void wToWS(const CommandArg* argv)
 {
 	Window focusedWindow;
@@ -513,7 +520,7 @@ const void reload(const CommandArg* argv)
 	detectScreens();
 
 	//Load config again
-	Err cfgErr = cfg.reload();
+	Err cfgErr = cfg.reloadFile();
 	//Error check
 	handleConfigErrs(cfgErr);
 
@@ -546,22 +553,6 @@ const void nextMonitor(const CommandArg* argv)
 	focusRoot(focusedWorkspaces[focusedScreen]);
 }
 
-void keyPress(XKeyEvent e)
-{
-	if(e.same_screen!=1) return;
-	updateMousePos();
-	//cout << "Keypress recieved\n";
-	KeySym keysym = XLookupKeysym(&e, 0);
-	//cout << "\t" << XKeysymToString(keysym) << " super: " << ((e.state & Mod4Mask) == Mod4Mask) << " alt: " << ((e.state & Mod1Mask) == Mod1Mask) << " shift: " << ((e.state & ShiftMask) == ShiftMask) << std::endl;
-	for(int i = 0; i < cfg.bindsc; i++)
-	{
-		if(cfg.binds[i].keysym == keysym && (e.state & cfg.binds[i].modifiers) == cfg.binds[i].modifiers)
-		{
-			cfg.binds[i].func(cfg.binds[i].args);
-		}
-	}
-}
-
 void configureRequest(XConfigureRequestEvent e)
 {
 	XWindowChanges changes;
@@ -811,7 +802,7 @@ void clientMessage(XClientMessageEvent e)
 	log("Client message: " << name);
 	if(e.message_type == XInternAtom(dpy, "_NET_CURRENT_DESKTOP", false))
 	{
-		changeWS({.num = (int)((long)e.data.l[0] + 1)});
+		cWS(e.data.l[0] + 1);
 		/*
 		//Change desktop
 		int nextWS = (long)e.data.l[0] + 1;
@@ -966,11 +957,6 @@ int main(int argc, char** argv)
 	XSetErrorHandler(OnXError);
 	XSelectInput(dpy, root, SubstructureRedirectMask | SubstructureNotifyMask | KeyPressMask | EnterWindowMask);
 
-	for(int i = 0; i < cfg.bindsc; i++)
-	{
-		XGrabKey(dpy, XKeysymToKeycode(dpy, cfg.binds[i].keysym), cfg.binds[i].modifiers, root, false, GrabModeAsync, GrabModeAsync);
-		//log("Grabbing " << XKeysymToString(cfg.binds[i].keysym));
-	}
 	XDefineCursor(dpy, root, XCreateFontCursor(dpy, XC_top_left_arrow));
 	//EWMH
 	initEWMH(&dpy, &root, cfg.numWS,cfg. workspaceNames);
@@ -1004,7 +990,7 @@ int main(int argc, char** argv)
 		switch(e.type)
 		{
 			case KeyPress:
-				keyPress(e.xkey);
+				keybindsModule.keyPress(e.xkey);
 				break;
 			case ConfigureRequest:
 				configureRequest(e.xconfigurerequest);
-- 
cgit v1.2.3


From ea827624d203c73af896669e161972fc8be022ed Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Sat, 27 May 2023 16:33:46 +1200
Subject: feat: Made it compile woo

Note: doesn't work yet though, as commands haven't all been registered yet
---
 config.cpp     |  15 ++-
 config.cpp.old | 364 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 config.h       |  82 +++++++------
 config.h.old   |  93 +++++++++++++++
 ewmh.cpp       |   6 +-
 ewmh.h         |   4 +-
 main.cpp       |  38 +++---
 old.config.cpp | 364 ---------------------------------------------------------
 old.config.h   |  93 ---------------
 9 files changed, 531 insertions(+), 528 deletions(-)
 create mode 100644 config.cpp.old
 create mode 100644 config.h.old
 delete mode 100644 old.config.cpp
 delete mode 100644 old.config.h

diff --git a/config.cpp b/config.cpp
index 6d8215c..422ec19 100644
--- a/config.cpp
+++ b/config.cpp
@@ -92,6 +92,7 @@ const void Config::addWorkspaceCmd(const CommandArg* argv)
 	int* prefs = new int[argv[1].numArr.size];
 	memcpy(prefs, argv[1].numArr.arr, argv[1].numArr.size * sizeof(int));
 	workspaces.push_back({argv[0].str, prefs, argv[1].numArr.size});
+	numWS++;
 }
 
 Config::Config(CommandsModule& commandsModule)
@@ -118,20 +119,23 @@ Config::Config(CommandsModule& commandsModule)
 	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, addWorkspaceArgs, this);
 }
 
-Err Config::reloadFile()
+std::vector<Err> Config::reloadFile()
 {
 	if(!loaded)
-		return {CFG_ERR_NON_FATAL, "Not loaded config yet"};
+		return {{CFG_ERR_NON_FATAL, "Not loaded config yet"}};
 	return loadFromFile(file);
 }
 
-Err Config::loadFromFile(string path)
+std::vector<Err> Config::loadFromFile(std::string path)
 {
+	std::vector<Err> ers;
+	
 	file = path;
 	//Set defaults
 	gaps = 3;
 	outerGaps = 3;
 	logFile = "/tmp/yatlog.txt";
+	numWS = 0;
 
 	//Probably need something for workspaces and binds too...
 
@@ -148,13 +152,12 @@ Err Config::loadFromFile(string path)
 		}
 		catch (Err e)
 		{
-			cout << "Error in config (line " << line <<  "): " << e.code << endl;
-			cout << "\tMessage: " << e.message << endl;
+			ers.push_back({e.code, "Error in config (line " + std::to_string(line) + "): " + std::to_string(e.code) + "\n\tMessage: " + e.message});
+		
 		}
 		line++;
 	}
 	loaded = true;
-	return {NOERR, ""};
 }
 
 Config::~Config()
diff --git a/config.cpp.old b/config.cpp.old
new file mode 100644
index 0000000..74ba0b0
--- /dev/null
+++ b/config.cpp.old
@@ -0,0 +1,364 @@
+#include "config.h"
+
+#include "error.h"
+#include "toml++/toml.hpp"
+#include "util.h"
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+
+#include <string>
+#include <map>
+
+//Just for testing
+#include <iostream>
+#include <vector>
+
+using std::map, std::string, std::to_string;
+
+// For testing
+using std::cout, std::endl, std::cerr;
+
+map<string, void(*) (const KeyArg arg)> funcNameMap = {
+	{"exit", exit},
+	{"spawn", spawn},
+	{"toggle", toggle},
+	{"kill", kill},
+	{"changeWS", changeWS},
+	{"wToWS", wToWS},
+	{"focChange", focChange},
+	{"wMove", wMove},
+	{"bashSpawn", bashSpawn},
+	{"reload", reload},
+	{"wsDump", wsDump},
+	{"nextMonitor", nextMonitor},
+};
+
+
+Config::Config()
+{
+}
+
+string to_string(string s)
+{
+	return s;
+}
+string to_string(bool b)
+{
+	if(b)
+		return "true";
+	else
+		return "false";
+}
+
+template <typename T>
+T Config::getValue(string path, Err* err)
+{
+	std::optional<T> tblVal = tbl.at_path(path).value<T>();
+	if(tblVal)
+		return *tblVal;
+	else
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		T val = *defaults.at_path(path).value<T>();
+		err->errorMessage += "\n\tValue for " + path + " is invalid, using default (" + to_string(val) + ")";
+		return val;
+	}
+}
+
+void Config::loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err)
+{
+	if(!tbl["Workspaces"]["workspaceNames"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\n\tworkspaceNames invalid array, using defaults";
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	workspaceNamesc = tbl["Workspaces"]["workspaceNames"].as_array()->size();
+	workspaceNames = new string[workspaceNamesc];
+	for(int i = 0; i < workspaceNamesc; i++)
+	{
+		auto element = tbl["Workspaces"]["workspaceNames"][i].value<string>();
+		if(element)
+			workspaceNames[i] = *element;
+		else
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\nelement " + to_string(i) + " in workspaceNames invalid, using defaults";
+			delete[] workspaceNames;
+			return loadWorkspaceArrays(defaults, defaults, err);
+		}
+	}
+	if(!tbl["Workspaces"]["screenPreferences"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\nscreenPreferences invalid array, using default";
+		delete[] workspaceNames;
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	screenPreferencesc = tbl["Workspaces"]["screenPreferences"].as_array()->size();
+	if(screenPreferencesc != workspaceNamesc)
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\nworkspaceNames and screenPreferences aren't the same length, using defaults";
+		delete[] workspaceNames;
+		return loadWorkspaceArrays(defaults, defaults, err);
+	}
+	screenPreferences = new int*[screenPreferencesc];
+	for(int i = 0; i < screenPreferencesc; i++)
+	{
+		if(!tbl["Workspaces"]["screenPreferences"][i].as_array())
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\telement " + to_string(i) + " in screenPreferences in invalid, using defaults";
+			delete[] workspaceNames;
+			for(int k = 0; k < i; k++)
+			{
+				delete[] screenPreferences[k];
+			}
+			delete[] screenPreferences;
+			return loadWorkspaceArrays(defaults, defaults, err);
+		}
+		int* wsScreens = new int[maxMonitors];
+		for(int j = 0; j < maxMonitors; j++)
+		{
+			if(tbl["Workspaces"]["screenPreferences"][i].as_array()->size() <= j)
+			{
+				wsScreens[j] = 0;
+				continue;
+			}
+			auto element = tbl["Workspaces"]["screenPreferences"][i][j].value<int>();
+			if(element)
+				wsScreens[j] = *element;
+			else
+			{
+				err->code = ERR_CFG_NON_FATAL;
+				err->errorMessage += "\telement " + to_string(i) + " " + to_string(j) + " in screenPreferences in invalid, using defaults";
+				delete[] workspaceNames;
+				for(int k = 0; k <= i; k++)
+				{
+					delete[] screenPreferences[k];
+				}
+				delete[] screenPreferences;
+				return loadWorkspaceArrays(defaults, defaults, err);
+			}
+		}
+		screenPreferences[i] = wsScreens;
+	}
+}
+
+void Config::loadStartupBash(toml::table tbl, toml::table defaults, Err* err)
+{
+	if(!tbl["Startup"]["startupBash"].as_array())
+	{
+		err->code = ERR_CFG_NON_FATAL;
+		err->errorMessage += "\n\tstartupBash array invalid, using default";
+		return loadStartupBash(defaults, defaults, err);
+	}
+	startupBashc = tbl["Startup"]["startupBash"].as_array()->size();
+	std::vector<string> startupBash;
+	for(int i = 0; i < startupBashc; i++)
+	{
+		auto element = tbl["Startup"]["startupBash"][i].value<string>();
+		if(element)
+			startupBash.push_back(*element);
+		else
+		{
+			err->code = ERR_CFG_NON_FATAL;
+			err->errorMessage += "\n\tstartupBash element " + to_string(i) + " invalid, skipping";
+		}
+	}
+	startupBashc = startupBash.size();
+	this->startupBash = new string[startupBashc];
+	for(int i = 0; i < startupBash.size(); i++)
+	{
+		this->startupBash[i] = startupBash[i];
+	}
+}
+
+Err Config::reload()
+{
+	if(!loaded)
+		return {ERR_CFG_FATAL, "Path not set yet, call loadFromFile before reload"};
+	return loadFromFile(path);
+}
+
+Err Config::loadFromFile(string path)
+{
+	if(loaded)
+	{
+		free();
+	}
+	loaded = true;
+	this->path = path;
+	Err err;
+	err.code = NOERR;
+	err.errorMessage = "";
+	defaults = toml::parse_file("/etc/YATwm/config.toml");
+	try
+	{
+		tbl = toml::parse_file(path);
+	}
+	catch (const toml::parse_error& parseErr)
+	{
+		err.code = ERR_CFG_FATAL;
+		string description = (string) parseErr.description();
+		string startCol = std::to_string(parseErr.source().begin.column);
+		string startLine = std::to_string(parseErr.source().begin.line);
+		string endCol = std::to_string(parseErr.source().end.column);
+		string endLine = std::to_string(parseErr.source().end.line);
+		string pos =  "Line " + startLine;
+		string what = parseErr.what();
+		err.errorMessage += "\n\t" + description + "\t(" + pos + ")" + "\n\tUsing /etc/YATwm/config.toml instead";
+		tbl = defaults;
+	}
+
+	//Startup
+	loadStartupBash(tbl, defaults, &err);
+
+	//Main
+	gaps = getValue<int>("Main.gaps", &err);
+	outerGaps = getValue<int>("Main.outerGaps", &err);
+	logFile = getValue<string>("Main.logFile", &err);
+
+	//Workspaces
+	numWS = getValue<int>("Workspaces.numWS", &err);
+	maxMonitors = getValue<int>("Workspaces.maxMonitors", &err);
+	loadWorkspaceArrays(tbl, defaults, &err);
+	
+	//Keybinds
+	bool swapSuperAlt = getValue<bool>("Keybinds.swapSuperAlt", &err);
+
+	toml::node_view<toml::node> bindsArr = tbl["Keybinds"]["key"];
+	if(!bindsArr.is_array())
+	{
+		err.code = ERR_CFG_NON_FATAL;
+		err.errorMessage += "\n\tBinds array not valid, using default";
+		bindsArr = defaults["Keybinds"]["key"];
+	}
+	std::vector<KeyBind> keyBinds;
+	bindsc = bindsArr.as_array()->size();
+	for(int i = 0; i < bindsc; i++)
+	{
+		KeyBind bind;
+		bind.modifiers = 0;
+		const std::optional<string> potentialBindString = bindsArr[i]["bind"].value<string>();
+		string bindString;
+		if(potentialBindString)
+			bindString = *potentialBindString;
+		else
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
+			continue;
+		}
+		std::vector<string> keys = split(bindString, '+');
+		for(string key : keys)
+		{
+			if(key == "mod")
+			{
+				if(!swapSuperAlt)
+					bind.modifiers |= Mod4Mask;
+				else
+					bind.modifiers |= Mod1Mask;
+			}
+			else if(key == "alt")
+			{
+				if(swapSuperAlt)
+					bind.modifiers |= Mod4Mask;
+				else
+					bind.modifiers |= Mod1Mask;
+			}
+			else if(key == "shift")
+			{
+				bind.modifiers |= ShiftMask;
+			}
+			else if(key == "control")
+			{
+				bind.modifiers |= ControlMask;
+			}
+			else
+			{
+				bind.keysym = XStringToKeysym(key.c_str());
+				if(bind.keysym == NoSymbol)
+				{
+					err.code = ERR_CFG_NON_FATAL;
+					err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
+					continue;
+				}
+			}
+		}
+		std::optional<string> potentialFuncString = bindsArr[i]["func"].value<string>();
+		string funcString;
+		if(potentialFuncString)
+			funcString = *potentialFuncString;
+		else
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
+			continue;
+		}
+		if(funcNameMap.count(funcString) == 0)
+		{
+			err.code = ERR_CFG_NON_FATAL;
+			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
+			continue;
+		}
+		void(* func) (const KeyArg arg) = funcNameMap.find(funcString)->second;
+		bind.func = func;
+
+		auto args = bindsArr[i]["args"];
+		if(args.is<int64_t>())
+		{
+			int num = *args.value<int>();
+			bind.args = {.num = num};
+		}
+		else if(args.is<string>())
+		{
+			string str = (string)*args.value<string>();
+			if(str == "Up")
+				bind.args = {.dir = Up};
+			else if (str == "Down")
+				bind.args = {.dir = Down};
+			else if (str == "Left")
+				bind.args = {.dir = Left};
+			else if (str == "Right")
+				bind.args = {.dir = Right};
+			else
+			{
+				bind.args = {.str = strdup(str.c_str())};
+			}
+		}
+		else
+		{
+			bind.args = {NULL};
+		}
+		keyBinds.push_back(bind);
+	}
+	bindsc = keyBinds.size();
+	binds = new KeyBind[bindsc];
+	for(int i = 0; i < bindsc; i++)
+	{
+		binds[i] = keyBinds[i];
+	}
+	if(err.code != NOERR)
+		err.errorMessage = err.errorMessage.substr(1);
+	return err;
+}
+
+Config::~Config()
+{
+	free();
+}
+void Config::free()
+{
+	delete[] startupBash;
+	delete[] workspaceNames;
+	for(int i = 0; i < screenPreferencesc; i++)
+	{
+		delete[] screenPreferences[i];
+	}
+	delete[] screenPreferences;
+	delete[] binds;
+	loaded = false;
+}
diff --git a/config.h b/config.h
index a31c1df..55e55aa 100644
--- a/config.h
+++ b/config.h
@@ -5,6 +5,7 @@
 #include <X11/keysym.h>
 
 #include <string>
+#include <vector>
 
 struct Workspace
 {
@@ -13,52 +14,47 @@ struct Workspace
 	int screenPreferencesc;
 };
 
-#define COMMAND(X) \
+#define COMMAND(X)								\
 	const void X (const CommandArg* argv)
 
 class Config
 {  
-	public:
-		Config(CommandsModule& commandsModule);
-		~Config();
-		void free();
+public:
+	Config(CommandsModule& commandsModule);
+	~Config();
+	void free();
 	
-		Err loadFromFile(std::string path);
-		Err reloadFile();
-		// Startup
-		std::string* startupBash;
-		int startupBashc;
-
-		// Main
-		int gaps;
-		int outerGaps;
-		std::string logFile;
-
-		// Workspaces
-		std::vector<Workspace> workspaces;
-		int numWS;
-		std::string* workspaceNames;
-		int workspaceNamesc;
-		int maxMonitors;
-		int** screenPreferences;
-		int screenPreferencesc;
-
-		// Config Commands
-		COMMAND(gapsCmd);
-		COMMAND(outerGapsCmd);
-		COMMAND(logFileCmd);
-		COMMAND(addWorkspaceCmd);
-
-		// Keybind Commands
-		COMMAND(exit);
-		COMMAND(spawn);
-		COMMAND(spawn_once);
-		COMMAND(changeWS);
-		COMMAND(wToWS);
-		COMMAND(focChange);
-		COMMAND(reload);
-	private:
-		CommandsModule& commandsModule;
-		bool loaded = false;
-		std::string file;
+	std::vector<Err> loadFromFile(std::string path);
+	std::vector<Err> reloadFile();
+	// Startup
+	std::string* startupBash;
+	int startupBashc;
+
+	// Main
+	int gaps;
+	int outerGaps;
+	std::string logFile;
+
+	// Workspaces
+	std::vector<Workspace> workspaces;
+	int numWS;
+
+	// Config Commands
+	COMMAND(gapsCmd);
+	COMMAND(outerGapsCmd);
+	COMMAND(logFileCmd);
+	COMMAND(addWorkspaceCmd);
+
+	// Keybind Commands
+	COMMAND(exit);
+	COMMAND(spawn);
+	COMMAND(spawn_once);
+	COMMAND(changeWS);
+	COMMAND(wToWS);
+	COMMAND(focChange);
+	COMMAND(reload);
+private:
+	CommandsModule& commandsModule;
+	bool loaded = false;
+	std::string file;
 };
diff --git a/config.h.old b/config.h.old
new file mode 100644
index 0000000..31005e7
--- /dev/null
+++ b/config.h.old
@@ -0,0 +1,93 @@
+#pragma once
+
+#include "error.h"
+
+#include <toml++/toml.hpp>
+
+#include <X11/X.h>
+#include <X11/keysym.h>
+
+#include <string>
+
+enum MoveDir
+{
+	Up,
+	Right,
+	Down,
+	Left
+};
+
+typedef union
+{
+	char* str;
+	int num;
+	MoveDir dir;
+} KeyArg;
+
+struct KeyBind
+{
+	unsigned int modifiers;
+	KeySym keysym;
+	void(* func) (const KeyArg arg);
+	KeyArg args;
+};
+
+//Keybind commands
+#define KEYCOM(X) \
+	void X (const KeyArg arg)
+KEYCOM(exit);
+KEYCOM(spawn);
+KEYCOM(toggle);
+KEYCOM(kill);
+KEYCOM(changeWS);
+KEYCOM(wToWS);
+KEYCOM(focChange);
+KEYCOM(wMove);
+KEYCOM(bashSpawn);
+KEYCOM(reload);
+KEYCOM(wsDump);
+KEYCOM(nextMonitor);
+
+class Config
+{   
+	public:
+		Config();
+		~Config();
+		void free();
+	
+		Err loadFromFile(std::string path);
+		Err reload();
+
+		// Startup
+		std::string* startupBash;
+		int startupBashc;
+
+		// Main
+		int gaps;
+		int outerGaps;
+		std::string logFile;
+
+		// Workspaces
+		int numWS;
+		std::string* workspaceNames;
+		int workspaceNamesc;
+		int maxMonitors;
+		int** screenPreferences;
+		int screenPreferencesc;
+
+		// Keybinds
+		KeyBind* binds;
+		int bindsc;
+	private:
+		template <typename T>
+		T getValue(std::string path, Err* err);
+
+		void loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err);
+		void loadStartupBash(toml::table tbl, toml::table defaults, Err* err);
+
+		toml::table tbl;
+		toml::table defaults;
+
+		bool loaded = false;
+		std::string path;
+};
diff --git a/ewmh.cpp b/ewmh.cpp
index eec5de9..5a7e76c 100644
--- a/ewmh.cpp
+++ b/ewmh.cpp
@@ -5,7 +5,7 @@
 Display** dpy_;
 Window* root_;
 
-void initEWMH(Display** dpy, Window* root, int numWS, const std::string workspaceNames[])
+void initEWMH(Display** dpy, Window* root, int numWS, std::vector<Workspace> workspaces)
 {
 	dpy_ = dpy;
 	root_ = root;
@@ -14,13 +14,13 @@ void initEWMH(Display** dpy, Window* root, int numWS, const std::string workspac
 	int wsNamesLen = numWS; //For  null bytes
 	for(int i = 0; i < numWS; i++)
 	{
-		wsNamesLen += workspaceNames[i].length();
+		wsNamesLen += workspaces[i].name.length();
 	}
 	char wsNames[wsNamesLen];
 	int pos = 0;
 	for(int i = 0; i < numWS; i++)
 	{
-		for(char toAdd : workspaceNames[i])
+		for(char toAdd : workspaces[i].name)
 		{
 			wsNames[pos++] = toAdd;		
 		}
diff --git a/ewmh.h b/ewmh.h
index 7b1b5f4..5fbc9a4 100644
--- a/ewmh.h
+++ b/ewmh.h
@@ -5,10 +5,12 @@
 
 #include <map>
 #include <string>
+#include <vector>
 
 #include "structs.h"
+#include "config.h"
 
-void initEWMH(Display** dpy, Window* root, int numWS, const std::string workspaceNames[]);
+void initEWMH(Display** dpy, Window* root, int numWS, std::vector<Workspace> workspaces);
 
 void updateClientList(std::map<int, Client> clients);
 
diff --git a/main.cpp b/main.cpp
index e4a4bcc..3f541a1 100644
--- a/main.cpp
+++ b/main.cpp
@@ -82,7 +82,7 @@ int FFCF(int sID);
 void detectScreens();
 void updateMousePos();
 void focusRoot(int root);
-void handleConfigErrs(Err cfgErr);
+void handleConfigErrs(vector<Err> cfgErrs);
 
 void configureRequest(XConfigureRequestEvent e);
 void mapRequest(XMapRequestEvent e);
@@ -123,9 +123,9 @@ void detectScreens()
 		log("\t\tw: " << screens[i].w << ", h: " << screens[i].h);
 		XFree(name);
 	}
-	for(int i = 0; i < cfg.numWS; i++)
+	for(int i = 0; i < cfg.workspaces.size(); i++)
 	{
-		if(cfg.screenPreferences[i][0] < nscreens && focusedWorkspaces[cfg.screenPreferences[i][0]] == 0)
+		if(cfg.workspaces[i].screenPreferences[0] < nscreens && focusedWorkspaces[cfg.workspaces[i].screenPreferences[0]] == 0)
 		{
 			//focusedWorkspaces[screenPreferences[i][0]] = i+1;
 		}
@@ -162,9 +162,9 @@ void focusRoot(int root)
 	//log("\tFocusing window: " << w);
 	XSetInputFocus(dpy, w, RevertToPointerRoot, CurrentTime);
 }
-void handleConfigErrs(Err cfgErr)
+void handleConfigErrs(vector<Err> cfgErrs)
 {
-	if(cfgErr.code!=NOERR)
+	for(Err cfgErr : cfgErrs)
 	{
 		if(cfgErr.code == CFG_ERR_FATAL)
 		{
@@ -268,19 +268,19 @@ void cWS(int newWS)
 
 	//log("Changing WS with keybind");
 
-	for(int i = 0; i < cfg.maxMonitors; i++)
+	for(int i = 0; i < nscreens; i++)
 	{
-		if(nscreens > cfg.screenPreferences[newWS - 1][i])
+		if(nscreens > cfg.workspaces[newWS - 1].screenPreferences[i])
 		{
-			int screen = cfg.screenPreferences[newWS - 1][i];
+			int screen = cfg.workspaces[newWS - 1].screenPreferences[i];
 			//log("Found screen (screen " << screenPreferences[arg.num - 1][i] << ")");
-			prevWS = focusedWorkspaces[cfg.screenPreferences[newWS - 1][i]];
+			prevWS = focusedWorkspaces[screen];
 			//log("Changed prevWS");
-			focusedWorkspaces[cfg.screenPreferences[newWS - 1][i]] = newWS;
+			focusedWorkspaces[screen] = newWS;
 			//log("Changed focusedWorkspaces");
-			if(focusedScreen != cfg.screenPreferences[newWS - 1][i])
+			if(focusedScreen != screen)
 			{
-				focusedScreen = cfg.screenPreferences[newWS - 1][i];
+				focusedScreen = screen;
 				XWarpPointer(dpy, root, root, 0, 0, 0, 0, screens[screen].x + screens[screen].w/2, screens[screen].y + screens[screen].h/2);
 			}
 			//log("Changed focusedScreen");
@@ -291,7 +291,8 @@ void cWS(int newWS)
 	//log("Finished changes");
 
 	//log(prevWS);
-	if(prevWS < 1 || prevWS > cfg.numWS)
+	// LOOK: what is this for?????
+	if(prevWS < 1 || prevWS > cfg.workspaces.size())
 	{
 		//untile(prevWS);
 	}
@@ -520,7 +521,7 @@ const void reload(const CommandArg* argv)
 	detectScreens();
 
 	//Load config again
-	Err cfgErr = cfg.reloadFile();
+	vector<Err> cfgErr = cfg.reloadFile();
 	//Error check
 	handleConfigErrs(cfgErr);
 
@@ -929,8 +930,9 @@ int main(int argc, char** argv)
 	std::string home = getenv("HOME");
 	std::string pathAfterHome = "/.config/YATwm/config.toml";
 	std::string file = home + pathAfterHome;
-	Err cfgErr = cfg.loadFromFile(file);
-
+	// Err cfgErr = cfg.loadFromFile(file);
+	std::vector<Err> cfgErr = cfg.loadFromFile("config");
+	
 	//Log
 	yatlog.open(cfg.logFile, std::ios_base::app);
 
@@ -959,7 +961,7 @@ int main(int argc, char** argv)
 
 	XDefineCursor(dpy, root, XCreateFontCursor(dpy, XC_top_left_arrow));
 	//EWMH
-	initEWMH(&dpy, &root, cfg.numWS,cfg. workspaceNames);
+	initEWMH(&dpy, &root, cfg.workspaces.size(), cfg.workspaces);
 	setCurrentDesktop(1);
 
 	for(int i = 1; i < cfg.numWS + 1; i++)
@@ -990,7 +992,7 @@ int main(int argc, char** argv)
 		switch(e.type)
 		{
 			case KeyPress:
-				keybindsModule.keyPress(e.xkey);
+				keybindsModule.handleKeypress(e.xkey);
 				break;
 			case ConfigureRequest:
 				configureRequest(e.xconfigurerequest);
diff --git a/old.config.cpp b/old.config.cpp
deleted file mode 100644
index 74ba0b0..0000000
--- a/old.config.cpp
+++ /dev/null
@@ -1,364 +0,0 @@
-#include "config.h"
-
-#include "error.h"
-#include "toml++/toml.hpp"
-#include "util.h"
-
-#include <X11/X.h>
-#include <X11/Xlib.h>
-
-#include <string>
-#include <map>
-
-//Just for testing
-#include <iostream>
-#include <vector>
-
-using std::map, std::string, std::to_string;
-
-// For testing
-using std::cout, std::endl, std::cerr;
-
-map<string, void(*) (const KeyArg arg)> funcNameMap = {
-	{"exit", exit},
-	{"spawn", spawn},
-	{"toggle", toggle},
-	{"kill", kill},
-	{"changeWS", changeWS},
-	{"wToWS", wToWS},
-	{"focChange", focChange},
-	{"wMove", wMove},
-	{"bashSpawn", bashSpawn},
-	{"reload", reload},
-	{"wsDump", wsDump},
-	{"nextMonitor", nextMonitor},
-};
-
-
-Config::Config()
-{
-}
-
-string to_string(string s)
-{
-	return s;
-}
-string to_string(bool b)
-{
-	if(b)
-		return "true";
-	else
-		return "false";
-}
-
-template <typename T>
-T Config::getValue(string path, Err* err)
-{
-	std::optional<T> tblVal = tbl.at_path(path).value<T>();
-	if(tblVal)
-		return *tblVal;
-	else
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		T val = *defaults.at_path(path).value<T>();
-		err->errorMessage += "\n\tValue for " + path + " is invalid, using default (" + to_string(val) + ")";
-		return val;
-	}
-}
-
-void Config::loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err)
-{
-	if(!tbl["Workspaces"]["workspaceNames"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tworkspaceNames invalid array, using defaults";
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	workspaceNamesc = tbl["Workspaces"]["workspaceNames"].as_array()->size();
-	workspaceNames = new string[workspaceNamesc];
-	for(int i = 0; i < workspaceNamesc; i++)
-	{
-		auto element = tbl["Workspaces"]["workspaceNames"][i].value<string>();
-		if(element)
-			workspaceNames[i] = *element;
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\nelement " + to_string(i) + " in workspaceNames invalid, using defaults";
-			delete[] workspaceNames;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-	}
-	if(!tbl["Workspaces"]["screenPreferences"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nscreenPreferences invalid array, using default";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferencesc = tbl["Workspaces"]["screenPreferences"].as_array()->size();
-	if(screenPreferencesc != workspaceNamesc)
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nworkspaceNames and screenPreferences aren't the same length, using defaults";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferences = new int*[screenPreferencesc];
-	for(int i = 0; i < screenPreferencesc; i++)
-	{
-		if(!tbl["Workspaces"]["screenPreferences"][i].as_array())
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\telement " + to_string(i) + " in screenPreferences in invalid, using defaults";
-			delete[] workspaceNames;
-			for(int k = 0; k < i; k++)
-			{
-				delete[] screenPreferences[k];
-			}
-			delete[] screenPreferences;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-		int* wsScreens = new int[maxMonitors];
-		for(int j = 0; j < maxMonitors; j++)
-		{
-			if(tbl["Workspaces"]["screenPreferences"][i].as_array()->size() <= j)
-			{
-				wsScreens[j] = 0;
-				continue;
-			}
-			auto element = tbl["Workspaces"]["screenPreferences"][i][j].value<int>();
-			if(element)
-				wsScreens[j] = *element;
-			else
-			{
-				err->code = ERR_CFG_NON_FATAL;
-				err->errorMessage += "\telement " + to_string(i) + " " + to_string(j) + " in screenPreferences in invalid, using defaults";
-				delete[] workspaceNames;
-				for(int k = 0; k <= i; k++)
-				{
-					delete[] screenPreferences[k];
-				}
-				delete[] screenPreferences;
-				return loadWorkspaceArrays(defaults, defaults, err);
-			}
-		}
-		screenPreferences[i] = wsScreens;
-	}
-}
-
-void Config::loadStartupBash(toml::table tbl, toml::table defaults, Err* err)
-{
-	if(!tbl["Startup"]["startupBash"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tstartupBash array invalid, using default";
-		return loadStartupBash(defaults, defaults, err);
-	}
-	startupBashc = tbl["Startup"]["startupBash"].as_array()->size();
-	std::vector<string> startupBash;
-	for(int i = 0; i < startupBashc; i++)
-	{
-		auto element = tbl["Startup"]["startupBash"][i].value<string>();
-		if(element)
-			startupBash.push_back(*element);
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\n\tstartupBash element " + to_string(i) + " invalid, skipping";
-		}
-	}
-	startupBashc = startupBash.size();
-	this->startupBash = new string[startupBashc];
-	for(int i = 0; i < startupBash.size(); i++)
-	{
-		this->startupBash[i] = startupBash[i];
-	}
-}
-
-Err Config::reload()
-{
-	if(!loaded)
-		return {ERR_CFG_FATAL, "Path not set yet, call loadFromFile before reload"};
-	return loadFromFile(path);
-}
-
-Err Config::loadFromFile(string path)
-{
-	if(loaded)
-	{
-		free();
-	}
-	loaded = true;
-	this->path = path;
-	Err err;
-	err.code = NOERR;
-	err.errorMessage = "";
-	defaults = toml::parse_file("/etc/YATwm/config.toml");
-	try
-	{
-		tbl = toml::parse_file(path);
-	}
-	catch (const toml::parse_error& parseErr)
-	{
-		err.code = ERR_CFG_FATAL;
-		string description = (string) parseErr.description();
-		string startCol = std::to_string(parseErr.source().begin.column);
-		string startLine = std::to_string(parseErr.source().begin.line);
-		string endCol = std::to_string(parseErr.source().end.column);
-		string endLine = std::to_string(parseErr.source().end.line);
-		string pos =  "Line " + startLine;
-		string what = parseErr.what();
-		err.errorMessage += "\n\t" + description + "\t(" + pos + ")" + "\n\tUsing /etc/YATwm/config.toml instead";
-		tbl = defaults;
-	}
-
-	//Startup
-	loadStartupBash(tbl, defaults, &err);
-
-	//Main
-	gaps = getValue<int>("Main.gaps", &err);
-	outerGaps = getValue<int>("Main.outerGaps", &err);
-	logFile = getValue<string>("Main.logFile", &err);
-
-	//Workspaces
-	numWS = getValue<int>("Workspaces.numWS", &err);
-	maxMonitors = getValue<int>("Workspaces.maxMonitors", &err);
-	loadWorkspaceArrays(tbl, defaults, &err);
-	
-	//Keybinds
-	bool swapSuperAlt = getValue<bool>("Keybinds.swapSuperAlt", &err);
-
-	toml::node_view<toml::node> bindsArr = tbl["Keybinds"]["key"];
-	if(!bindsArr.is_array())
-	{
-		err.code = ERR_CFG_NON_FATAL;
-		err.errorMessage += "\n\tBinds array not valid, using default";
-		bindsArr = defaults["Keybinds"]["key"];
-	}
-	std::vector<KeyBind> keyBinds;
-	bindsc = bindsArr.as_array()->size();
-	for(int i = 0; i < bindsc; i++)
-	{
-		KeyBind bind;
-		bind.modifiers = 0;
-		const std::optional<string> potentialBindString = bindsArr[i]["bind"].value<string>();
-		string bindString;
-		if(potentialBindString)
-			bindString = *potentialBindString;
-		else
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
-			continue;
-		}
-		std::vector<string> keys = split(bindString, '+');
-		for(string key : keys)
-		{
-			if(key == "mod")
-			{
-				if(!swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "alt")
-			{
-				if(swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "shift")
-			{
-				bind.modifiers |= ShiftMask;
-			}
-			else if(key == "control")
-			{
-				bind.modifiers |= ControlMask;
-			}
-			else
-			{
-				bind.keysym = XStringToKeysym(key.c_str());
-				if(bind.keysym == NoSymbol)
-				{
-					err.code = ERR_CFG_NON_FATAL;
-					err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
-					continue;
-				}
-			}
-		}
-		std::optional<string> potentialFuncString = bindsArr[i]["func"].value<string>();
-		string funcString;
-		if(potentialFuncString)
-			funcString = *potentialFuncString;
-		else
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
-		}
-		if(funcNameMap.count(funcString) == 0)
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
-		}
-		void(* func) (const KeyArg arg) = funcNameMap.find(funcString)->second;
-		bind.func = func;
-
-		auto args = bindsArr[i]["args"];
-		if(args.is<int64_t>())
-		{
-			int num = *args.value<int>();
-			bind.args = {.num = num};
-		}
-		else if(args.is<string>())
-		{
-			string str = (string)*args.value<string>();
-			if(str == "Up")
-				bind.args = {.dir = Up};
-			else if (str == "Down")
-				bind.args = {.dir = Down};
-			else if (str == "Left")
-				bind.args = {.dir = Left};
-			else if (str == "Right")
-				bind.args = {.dir = Right};
-			else
-			{
-				bind.args = {.str = strdup(str.c_str())};
-			}
-		}
-		else
-		{
-			bind.args = {NULL};
-		}
-		keyBinds.push_back(bind);
-	}
-	bindsc = keyBinds.size();
-	binds = new KeyBind[bindsc];
-	for(int i = 0; i < bindsc; i++)
-	{
-		binds[i] = keyBinds[i];
-	}
-	if(err.code != NOERR)
-		err.errorMessage = err.errorMessage.substr(1);
-	return err;
-}
-
-Config::~Config()
-{
-	free();
-}
-void Config::free()
-{
-	delete[] startupBash;
-	delete[] workspaceNames;
-	for(int i = 0; i < screenPreferencesc; i++)
-	{
-		delete[] screenPreferences[i];
-	}
-	delete[] screenPreferences;
-	delete[] binds;
-	loaded = false;
-}
diff --git a/old.config.h b/old.config.h
deleted file mode 100644
index 31005e7..0000000
--- a/old.config.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "error.h"
-
-#include <toml++/toml.hpp>
-
-#include <X11/X.h>
-#include <X11/keysym.h>
-
-#include <string>
-
-enum MoveDir
-{
-	Up,
-	Right,
-	Down,
-	Left
-};
-
-typedef union
-{
-	char* str;
-	int num;
-	MoveDir dir;
-} KeyArg;
-
-struct KeyBind
-{
-	unsigned int modifiers;
-	KeySym keysym;
-	void(* func) (const KeyArg arg);
-	KeyArg args;
-};
-
-//Keybind commands
-#define KEYCOM(X) \
-	void X (const KeyArg arg)
-KEYCOM(exit);
-KEYCOM(spawn);
-KEYCOM(toggle);
-KEYCOM(kill);
-KEYCOM(changeWS);
-KEYCOM(wToWS);
-KEYCOM(focChange);
-KEYCOM(wMove);
-KEYCOM(bashSpawn);
-KEYCOM(reload);
-KEYCOM(wsDump);
-KEYCOM(nextMonitor);
-
-class Config
-{   
-	public:
-		Config();
-		~Config();
-		void free();
-	
-		Err loadFromFile(std::string path);
-		Err reload();
-
-		// Startup
-		std::string* startupBash;
-		int startupBashc;
-
-		// Main
-		int gaps;
-		int outerGaps;
-		std::string logFile;
-
-		// Workspaces
-		int numWS;
-		std::string* workspaceNames;
-		int workspaceNamesc;
-		int maxMonitors;
-		int** screenPreferences;
-		int screenPreferencesc;
-
-		// Keybinds
-		KeyBind* binds;
-		int bindsc;
-	private:
-		template <typename T>
-		T getValue(std::string path, Err* err);
-
-		void loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err);
-		void loadStartupBash(toml::table tbl, toml::table defaults, Err* err);
-
-		toml::table tbl;
-		toml::table defaults;
-
-		bool loaded = false;
-		std::string path;
-};
-- 
cgit v1.2.3


From 6b3dff404248bcf03e0bf0463a8c53d8918f7eec Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Wed, 31 May 2023 20:55:49 +1200
Subject: Added support for commands without a module

Also made it easier to add commands by making the ~addCommand~
function accept a vector for ~argTypes~ and then convert it.
---
 commands.cpp          |  19 ++++++++-
 commands.h            |  73 ++++++++++++++++++++--------------
 compile_commands.json | 108 +++++++++++++++++++++++++++++++++++++++++++++++++-
 config.cpp            |  37 ++++-------------
 config.h              |   1 -
 main.cpp              |   2 +
 6 files changed, 178 insertions(+), 62 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index 322d160..549775e 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -47,6 +47,20 @@ void CommandsModule::addCommand(Command c)
 	}
 	commandList.push_back(c);
 }
+void CommandsModule::addCommand(std::string name, const void (*func)(const CommandArg *), const int argc, CommandArgType *argTypes)
+{
+	Command c = {name, nullptr, func, argc, argTypes, nullptr};
+	addCommand(c);
+}
+void CommandsModule::addCommand(std::string name, const void(*func)(const CommandArg*), const int argc, std::vector<CommandArgType> argTypes)
+{
+	CommandArgType* argTypesArr = new CommandArgType[argc];
+	for(int i = 0; i < argc; i++)
+	{
+		argTypesArr[i] = argTypes[i];
+	}
+	addCommand(name, func, argc, argTypesArr);
+}
 
 struct NameMatches
 {
@@ -145,7 +159,10 @@ void CommandsModule::runCommand(string command)
 	CommandArg* args = getCommandArgs(split, cmd->argTypes, cmd->argc);
 	try
 	{
-		cmd->func(*cmd->module, args);
+		if(cmd->module == nullptr)
+			cmd->staticFunc(args);
+		else
+			cmd->func(*cmd->module, args);
 	}
 	catch (Err e)
 	{
diff --git a/commands.h b/commands.h
index 2e364ac..92801bd 100644
--- a/commands.h
+++ b/commands.h
@@ -8,20 +8,20 @@
 #include <functional>
 
 enum MoveDir
-{
-	UP,
-	RIGHT,
-	DOWN,
-	LEFT
-};
+	{
+		UP,
+		RIGHT,
+		DOWN,
+		LEFT
+	};
 enum CommandArgType
-{
-	STR,
-	NUM,
-	MOVDIR,
-	STR_REST,
-	NUM_ARR_REST
-};
+	{
+		STR,
+		NUM,
+		MOVDIR,
+		STR_REST,
+		NUM_ARR_REST
+	};
 
 struct NumArr
 {
@@ -40,27 +40,32 @@ struct Command
 {
 	const std::string name;
 	const std::function<void(std::any&, const CommandArg* argv)> func;
+	const std::function<void(const CommandArg* argv)> staticFunc;
 	const int argc;
 	CommandArgType* argTypes;
 	std::any* module;
 };
 class CommandsModule
 {
-	private:
-		std::vector<Command> commandList;
-		std::vector<std::string> splitCommand(std::string command);
-		CommandArg* getCommandArgs(std::vector<std::string>& args, const CommandArgType* argTypes, const int argc);
-		const void printHello(const CommandArg* argv);
-		const void echo(const CommandArg* argv);
-	public:   
-		CommandsModule();
-		~CommandsModule();
-		template <class T>
-		void addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, CommandArgType* argTypes, T* module);
-		void addCommand(Command c);
-		Command* lookupCommand(std::string name);
-		void runCommand(std::string command);
-		Err checkCommand(std::string command);
+private:
+	std::vector<Command> commandList;
+	std::vector<std::string> splitCommand(std::string command);
+	CommandArg* getCommandArgs(std::vector<std::string>& args, const CommandArgType* argTypes, const int argc);
+	const void printHello(const CommandArg* argv);
+	const void echo(const CommandArg* argv);
+public:   
+	CommandsModule();
+	~CommandsModule();
+	template <class T>
+	void addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, CommandArgType* argTypes, T* module);
+	void addCommand(std::string name, const void(*func)(const CommandArg*), const int argc, CommandArgType* argTypes);
+	template <class T>
+	void addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, std::vector<CommandArgType> argTypes, T* module);
+	void addCommand(std::string name, const void(*func)(const CommandArg*), const int argc, std::vector<CommandArgType> argTypes);
+	void addCommand(Command c);
+	Command* lookupCommand(std::string name);
+	void runCommand(std::string command);
+	Err checkCommand(std::string command);
 };
 
 // YES I KNOW THIS IS BAD
@@ -68,6 +73,16 @@ class CommandsModule
 template <class T>
 void CommandsModule::addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, CommandArgType* argTypes, T* module)
 {
-	Command c = {name, (const void*(std::any::*)(const CommandArg* argv)) func, argc, argTypes, (std::any*)module};
+	Command c = {name, (const void*(std::any::*)(const CommandArg* argv)) func, nullptr, argc, argTypes, (std::any*)module};
 	addCommand(c);
 }
+template <class T>
+void CommandsModule::addCommand(std::string name, const void(T::*func)(const CommandArg*), const int argc, std::vector<CommandArgType> argTypes, T* module)
+{
+	CommandArgType* argTypesArr = new CommandArgType[argc];
+	for(int i = 0; i < argc; i++)
+	{
+		argTypesArr[i] = argTypes[i];
+	}
+	addCommand(name, func, argc, argTypesArr, module);
+}
diff --git a/compile_commands.json b/compile_commands.json
index 6e04525..3997f42 100644
--- a/compile_commands.json
+++ b/compile_commands.json
@@ -3,10 +3,30 @@
     "arguments": [
       "/usr/bin/g++",
       "-std=c++17",
-      "-Iinclude",
       "-I/usr/include/gdk-pixbuf-2.0",
       "-I/usr/include/glib-2.0",
-      "-I/usr/lib/glib-2.0/include",
+      "-I/usr/lib64/glib-2.0/include",
+      "-I/usr/include/sysprof-4",
+      "-I/usr/include/libpng16",
+      "-I/usr/include/libmount",
+      "-I/usr/include/blkid",
+      "-pthread",
+      "-c",
+      "-o",
+      "ewmh.o",
+      "ewmh.cpp"
+    ],
+    "directory": "/home/boss/Documents/Coding/WM/YATwm",
+    "file": "/home/boss/Documents/Coding/WM/YATwm/ewmh.cpp",
+    "output": "/home/boss/Documents/Coding/WM/YATwm/ewmh.o"
+  },
+  {
+    "arguments": [
+      "/usr/bin/g++",
+      "-std=c++17",
+      "-I/usr/include/gdk-pixbuf-2.0",
+      "-I/usr/include/glib-2.0",
+      "-I/usr/lib64/glib-2.0/include",
       "-I/usr/include/sysprof-4",
       "-I/usr/include/libpng16",
       "-I/usr/include/libmount",
@@ -20,5 +40,89 @@
     "directory": "/home/boss/Documents/Coding/WM/YATwm",
     "file": "/home/boss/Documents/Coding/WM/YATwm/main.cpp",
     "output": "/home/boss/Documents/Coding/WM/YATwm/main.o"
+  },
+  {
+    "arguments": [
+      "/usr/bin/g++",
+      "-std=c++17",
+      "-I/usr/include/gdk-pixbuf-2.0",
+      "-I/usr/include/glib-2.0",
+      "-I/usr/lib64/glib-2.0/include",
+      "-I/usr/include/sysprof-4",
+      "-I/usr/include/libpng16",
+      "-I/usr/include/libmount",
+      "-I/usr/include/blkid",
+      "-pthread",
+      "-c",
+      "-o",
+      "util.o",
+      "util.cpp"
+    ],
+    "directory": "/home/boss/Documents/Coding/WM/YATwm",
+    "file": "/home/boss/Documents/Coding/WM/YATwm/util.cpp",
+    "output": "/home/boss/Documents/Coding/WM/YATwm/util.o"
+  },
+  {
+    "arguments": [
+      "/usr/bin/g++",
+      "-std=c++17",
+      "-I/usr/include/gdk-pixbuf-2.0",
+      "-I/usr/include/glib-2.0",
+      "-I/usr/lib64/glib-2.0/include",
+      "-I/usr/include/sysprof-4",
+      "-I/usr/include/libpng16",
+      "-I/usr/include/libmount",
+      "-I/usr/include/blkid",
+      "-pthread",
+      "-c",
+      "-o",
+      "config.o",
+      "config.cpp"
+    ],
+    "directory": "/home/boss/Documents/Coding/WM/YATwm",
+    "file": "/home/boss/Documents/Coding/WM/YATwm/config.cpp",
+    "output": "/home/boss/Documents/Coding/WM/YATwm/config.o"
+  },
+  {
+    "arguments": [
+      "/usr/bin/g++",
+      "-std=c++17",
+      "-I/usr/include/gdk-pixbuf-2.0",
+      "-I/usr/include/glib-2.0",
+      "-I/usr/lib64/glib-2.0/include",
+      "-I/usr/include/sysprof-4",
+      "-I/usr/include/libpng16",
+      "-I/usr/include/libmount",
+      "-I/usr/include/blkid",
+      "-pthread",
+      "-c",
+      "-o",
+      "keybinds.o",
+      "keybinds.cpp"
+    ],
+    "directory": "/home/boss/Documents/Coding/WM/YATwm",
+    "file": "/home/boss/Documents/Coding/WM/YATwm/keybinds.cpp",
+    "output": "/home/boss/Documents/Coding/WM/YATwm/keybinds.o"
+  },
+  {
+    "arguments": [
+      "/usr/bin/g++",
+      "-std=c++17",
+      "-I/usr/include/gdk-pixbuf-2.0",
+      "-I/usr/include/glib-2.0",
+      "-I/usr/lib64/glib-2.0/include",
+      "-I/usr/include/sysprof-4",
+      "-I/usr/include/libpng16",
+      "-I/usr/include/libmount",
+      "-I/usr/include/blkid",
+      "-pthread",
+      "-c",
+      "-o",
+      "commands.o",
+      "commands.cpp"
+    ],
+    "directory": "/home/boss/Documents/Coding/WM/YATwm",
+    "file": "/home/boss/Documents/Coding/WM/YATwm/commands.cpp",
+    "output": "/home/boss/Documents/Coding/WM/YATwm/commands.o"
   }
 ]
diff --git a/config.cpp b/config.cpp
index 422ec19..74a4a1d 100644
--- a/config.cpp
+++ b/config.cpp
@@ -41,18 +41,6 @@ const void Config::spawn_once(const CommandArg* argv)
 	}
 }
 
-const void Config::spawn(const CommandArg* argv)
-{
-	if(fork() == 0)
-	{
-		int null = open("/dev/null", O_WRONLY);
-		dup2(null, 0);
-		dup2(null, 1);
-		dup2(null, 2);
-		system(argv[0].str);
-		exit(0);
-	}
-}
 const void Config::changeWS(const CommandArg* argv)
 {
 	cout << "changeWS called" << endl;
@@ -99,24 +87,14 @@ Config::Config(CommandsModule& commandsModule)
 	: commandsModule(commandsModule)
 {
 	//Register commands for keybinds
-	CommandArgType* spawnArgs = new CommandArgType[1];
-	spawnArgs[0] = STR_REST;
-	commandsModule.addCommand("spawn", &Config::spawn, 1, spawnArgs, this);
-	commandsModule.addCommand("spawn_once", &Config::spawn_once, 1, spawnArgs, this);
+	commandsModule.addCommand("spawn_once", &Config::spawn_once, 1, {STR_REST}, this);
 	commandsModule.addCommand("reload", &Config::reload, 0, {}, this);
 
 	//Register commands for config
-	CommandArgType* gapsArgs = new CommandArgType[1];
-	gapsArgs[0] = NUM;
-	commandsModule.addCommand("gaps", &Config::gapsCmd, 1, gapsArgs, this);
-	commandsModule.addCommand("outergaps", &Config::outerGapsCmd, 1, gapsArgs, this);
-	CommandArgType* logFileArgs = new CommandArgType[1];
-	logFileArgs[0] = STR_REST;
-	commandsModule.addCommand("logfile", &Config::logFileCmd, 1, logFileArgs, this);
-	CommandArgType* addWorkspaceArgs = new CommandArgType[2];
-	addWorkspaceArgs[0] = STR;
-	addWorkspaceArgs[1] = NUM_ARR_REST;
-	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, addWorkspaceArgs, this);
+	commandsModule.addCommand("gaps", &Config::gapsCmd, 1, {NUM}, this);
+	commandsModule.addCommand("outergaps", &Config::outerGapsCmd, 1, {NUM}, this);
+	commandsModule.addCommand("logfile", &Config::logFileCmd, 1, {STR_REST}, this);
+	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, {STR, NUM_ARR_REST}, this);
 }
 
 std::vector<Err> Config::reloadFile()
@@ -128,7 +106,7 @@ std::vector<Err> Config::reloadFile()
 
 std::vector<Err> Config::loadFromFile(std::string path)
 {
-	std::vector<Err> ers;
+	std::vector<Err> errs;
 	
 	file = path;
 	//Set defaults
@@ -152,12 +130,13 @@ std::vector<Err> Config::loadFromFile(std::string path)
 		}
 		catch (Err e)
 		{
-			ers.push_back({e.code, "Error in config (line " + std::to_string(line) + "): " + std::to_string(e.code) + "\n\tMessage: " + e.message});
+			errs.push_back({e.code, "Error in config (line " + std::to_string(line) + "): " + std::to_string(e.code) + "\n\tMessage: " + e.message});
 		
 		}
 		line++;
 	}
 	loaded = true;
+	return errs;
 }
 
 Config::~Config()
diff --git a/config.h b/config.h
index 55e55aa..e6d6227 100644
--- a/config.h
+++ b/config.h
@@ -47,7 +47,6 @@ public:
 
 	// Keybind Commands
 	COMMAND(exit);
-	COMMAND(spawn);
 	COMMAND(spawn_once);
 	COMMAND(changeWS);
 	COMMAND(wToWS);
diff --git a/main.cpp b/main.cpp
index 3f541a1..bf523fd 100644
--- a/main.cpp
+++ b/main.cpp
@@ -925,6 +925,8 @@ int main(int argc, char** argv)
 	dpy = XOpenDisplay(nullptr);
 	root = Window(DefaultRootWindow(dpy));
 
+	// Adding commands
+	commandsModule.addCommand("spawn", spawn, 1, {STR_REST});
 
 	//Config
 	std::string home = getenv("HOME");
-- 
cgit v1.2.3


From 01bc6a33eb235cd10851e2c31b99e6840603ca7d Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Thu, 1 Jun 2023 12:53:13 +1200
Subject: IT WORKS!!!!!!

The new config commands system works, finally able to run this as a
test and it works!!!!!.
Still more to be done but at least it works.
---
 commands.cpp |  1 +
 config       | 13 ++-----------
 config.cpp   | 42 ------------------------------------------
 config.h     | 13 ++-----------
 keybinds.cpp | 27 +++++++++++----------------
 keybinds.h   | 10 ++++------
 main.cpp     | 49 ++++++++++++++++++++++++++++++++-----------------
 util.h       |  7 +++++++
 8 files changed, 59 insertions(+), 103 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index 549775e..09bdf62 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -150,6 +150,7 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 
 void CommandsModule::runCommand(string command)
 {
+	cout << command << endl;
 	vector<string> split = splitCommand(command);
 	Command* cmd = lookupCommand(split[0]);
 	if(cmd == nullptr)
diff --git a/config b/config
index 3dcab8b..5eb0c4a 100644
--- a/config
+++ b/config
@@ -1,15 +1,6 @@
 # This is a comment
-bind e exit
-bind q exit
-bind o echo test
-bind x spawn notify-send stuff
-bind a spawn xterm
-bind r reload
-spawn "notify-send test"
-spawn_once "notify-send once"
+bind mod+e exit
+bind mod+Return spawn kitty
 gaps 10
 outergaps 10
 addworkspace "1: A" 1
-addworkspace "2: B" 1
-addworkspace "5: A" 2 1
-addworkspace "6: B" 2 1
\ No newline at end of file
diff --git a/config.cpp b/config.cpp
index 74a4a1d..cff7a45 100644
--- a/config.cpp
+++ b/config.cpp
@@ -22,44 +22,6 @@ using std::string;
 // For testing
 using std::cout, std::endl;
 
-const void Config::exit(const CommandArg* argv)
-{
-	cout << "exit called" << endl;
-}
-const void Config::spawn_once(const CommandArg* argv)
-{
-	if(loaded)
-		return;
-	if(fork() == 0)
-	{
-		int null = open("/dev/null", O_WRONLY);
-		dup2(null, 0);
-		dup2(null, 1);
-		dup2(null, 2);
-		system(argv[0].str);
-		exit(0);
-	}
-}
-
-const void Config::changeWS(const CommandArg* argv)
-{
-	cout << "changeWS called" << endl;
-}
-const void Config::wToWS(const CommandArg* argv)
-{
-	cout << "wToWS called" << endl;
-}
-const void Config::focChange(const CommandArg* argv)
-{
-	cout << "focChange called" << endl;
-}
-const void Config::reload(const CommandArg* argv)
-{
-	// Note: this is kinda broken cos it doesn't ungrab keys, i'll do that later.
-	cout << "Reloading config" << endl;
-	reloadFile();
-}
-
 const void Config::gapsCmd(const CommandArg* argv)
 {
 	gaps = argv[0].num;
@@ -86,10 +48,6 @@ const void Config::addWorkspaceCmd(const CommandArg* argv)
 Config::Config(CommandsModule& commandsModule)
 	: commandsModule(commandsModule)
 {
-	//Register commands for keybinds
-	commandsModule.addCommand("spawn_once", &Config::spawn_once, 1, {STR_REST}, this);
-	commandsModule.addCommand("reload", &Config::reload, 0, {}, this);
-
 	//Register commands for config
 	commandsModule.addCommand("gaps", &Config::gapsCmd, 1, {NUM}, this);
 	commandsModule.addCommand("outergaps", &Config::outerGapsCmd, 1, {NUM}, this);
diff --git a/config.h b/config.h
index e6d6227..b02dc9e 100644
--- a/config.h
+++ b/config.h
@@ -26,9 +26,6 @@ public:
 	
 	std::vector<Err> loadFromFile(std::string path);
 	std::vector<Err> reloadFile();
-	// Startup
-	std::string* startupBash;
-	int startupBashc;
 
 	// Main
 	int gaps;
@@ -38,6 +35,8 @@ public:
 	// Workspaces
 	std::vector<Workspace> workspaces;
 	int numWS;
+	bool loaded = false;
+
 
 	// Config Commands
 	COMMAND(gapsCmd);
@@ -45,15 +44,7 @@ public:
 	COMMAND(logFileCmd);
 	COMMAND(addWorkspaceCmd);
 
-	// Keybind Commands
-	COMMAND(exit);
-	COMMAND(spawn_once);
-	COMMAND(changeWS);
-	COMMAND(wToWS);
-	COMMAND(focChange);
-	COMMAND(reload);
 private:
 	CommandsModule& commandsModule;
-	bool loaded = false;
 	std::string file;
 };
diff --git a/keybinds.cpp b/keybinds.cpp
index ee6892a..30b3fd0 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -10,17 +10,14 @@
 
 using std::string, std::cout, std::endl;
 
-KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Display* dpy, Window root)
-	:commandsModule(commandsModule)
+KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Globals& globals)
+	:commandsModule(commandsModule),
+	globals(globals)
 {
-	this->dpy = dpy;
-	this->root = root;
 	CommandArgType* bindArgs = new CommandArgType[2];
 	bindArgs[0] = STR;
 	bindArgs[1] = STR_REST;
 	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, bindArgs, this);
-	commandsModule.addCommand("exit", &KeybindsModule::exit, 0, {}, this);
-	exitNow = false;
 }
 
 const void KeybindsModule::handleKeypress(XKeyEvent e)
@@ -29,7 +26,7 @@ const void KeybindsModule::handleKeypress(XKeyEvent e)
 	//updateMousePos();
 	for(Keybind bind : binds)
 	{
-		if(bind.modifiers == e.state && bind.key == e.keycode)
+		if(bind.modifiers == e.state && bind.key == XKeycodeToKeysym(globals.dpy, e.keycode, 0))
 		{
 			commandsModule.runCommand(bind.command);
 		}
@@ -46,6 +43,7 @@ const void KeybindsModule::bind(const CommandArg* argv)
 	}
 	std::vector<string> keys = split(argv[0].str, '+');
 	Keybind bind;
+	bind.modifiers = 0;
 	for(string key : keys)
 	{
 		if(key == "mod")
@@ -54,7 +52,7 @@ const void KeybindsModule::bind(const CommandArg* argv)
 		}
 		else if(key == "alt")
 		{
-			bind.modifiers |= Mod1Mask;
+			bind.modifiers |= Mod4Mask;
 		}
 		else if(key == "shift")
 		{
@@ -66,7 +64,8 @@ const void KeybindsModule::bind(const CommandArg* argv)
 		}
 		else
 		{
-			bind.key = XKeysymToKeycode(dpy, XStringToKeysym(key.c_str()));
+			KeySym s = XStringToKeysym(key.c_str());
+			bind.key = s;
 			if(bind.key == NoSymbol)
 			{
 				throw Err(CFG_ERR_KEYBIND, "Keybind '" + string(argv[0].str) + "' is invalid!");
@@ -74,12 +73,8 @@ const void KeybindsModule::bind(const CommandArg* argv)
 			}
 		}
 	}
-	XGrabKey(dpy, bind.key, bind.modifiers, root, false, GrabModeAsync, GrabModeAsync);
+	bind.command = argv[1].str;
+	KeyCode c = XKeysymToKeycode(globals.dpy, bind.key);
+	XGrabKey(globals.dpy, c, bind.modifiers, globals.root, False, GrabModeAsync, GrabModeAsync);
 	binds.push_back(bind);
 }
-
-const void KeybindsModule::exit(const CommandArg* argv)
-{
-	exitNow = true;
-	cout << "Exiting..." << endl;
-}
diff --git a/keybinds.h b/keybinds.h
index c0cc955..43f6ef3 100644
--- a/keybinds.h
+++ b/keybinds.h
@@ -8,24 +8,22 @@
 #include <vector>
 
 #include "commands.h"
+#include "util.h"
 
 struct Keybind {
-	KeyCode key;
+	KeySym key;
 	unsigned int modifiers;
 	std::string command;
 };
 
 class KeybindsModule {
 public:
-	KeybindsModule(CommandsModule& commandsModule, Display* dpy, Window root);
+	KeybindsModule(CommandsModule& commandsModule, Globals& globals);
 	~KeybindsModule() = default;
 	const void bind(const CommandArg* argv);
-	const void exit(const CommandArg* argv);
 	const void handleKeypress(XKeyEvent e);
 private:
 	std::vector<Keybind> binds;
-	bool exitNow;
 	CommandsModule& commandsModule;
-	Display* dpy;
-	Window root;
+	Globals& globals;
 };
diff --git a/main.cpp b/main.cpp
index bf523fd..034554c 100644
--- a/main.cpp
+++ b/main.cpp
@@ -44,12 +44,14 @@ std::ofstream yatlog;
 
 #define log(x) yatlog << x << std::endl
 
-Display* dpy;
-Window root;
+Globals globals;
+
+Display*& dpy = globals.dpy;
+Window& root = globals.root;
 
 CommandsModule commandsModule;
 Config cfg(commandsModule);
-KeybindsModule keybindsModule(commandsModule, dpy, root);
+KeybindsModule keybindsModule(commandsModule, globals);
 
 int sW, sH;
 int bH;
@@ -514,7 +516,12 @@ const void bashSpawn(const CommandArg* argv)
 		system(argv[0].str);
 		exit(0);
 	}
-
+}
+const void bashSpawnOnce(const CommandArg* argv)
+{
+	if(cfg.loaded)
+		return;
+	else bashSpawn(argv);
 }
 const void reload(const CommandArg* argv)
 {
@@ -915,18 +922,29 @@ int main(int argc, char** argv)
 		{
 			const char* version =
 				"YATwm for X\n"
-				"version 0.0.0";
+				"version 0.1.0";
 			cout << version << endl;
 			return 0;
 		}
 	}
 	//Important init stuff
 	mX = mY = 0;
-	dpy = XOpenDisplay(nullptr);
-	root = Window(DefaultRootWindow(dpy));
+	globals.dpy = XOpenDisplay(nullptr);
+	globals.root = Window(DefaultRootWindow(dpy));
 
 	// Adding commands
+	commandsModule.addCommand("exit", exit, 0, {});
 	commandsModule.addCommand("spawn", spawn, 1, {STR_REST});
+	commandsModule.addCommand("toggle", toggle, 0, {});
+	commandsModule.addCommand("kill", kill, 0, {});
+	commandsModule.addCommand("changeWS", changeWS, 1, {NUM});
+	commandsModule.addCommand("wToWS", wToWS, 1, {NUM});
+	commandsModule.addCommand("focChange", focChange, 1, {MOVDIR});
+	commandsModule.addCommand("bashSpawn", bashSpawn, 1, {STR_REST});
+	commandsModule.addCommand("bashSpawnOnce", bashSpawnOnce, 1, {STR_REST});
+	commandsModule.addCommand("reload", reload, 0, {});
+	commandsModule.addCommand("wsDump", wsDump, 0, {});
+	commandsModule.addCommand("nextMonitor", nextMonitor, 0, {});
 
 	//Config
 	std::string home = getenv("HOME");
@@ -934,7 +952,7 @@ int main(int argc, char** argv)
 	std::string file = home + pathAfterHome;
 	// Err cfgErr = cfg.loadFromFile(file);
 	std::vector<Err> cfgErr = cfg.loadFromFile("config");
-	
+
 	//Log
 	yatlog.open(cfg.logFile, std::ios_base::app);
 
@@ -946,26 +964,31 @@ int main(int argc, char** argv)
 	//Notifications
 	notify_init("YATwm");
 
+	cout << 0 << endl;
 	//Error check config
 	handleConfigErrs(cfgErr);
-	
+	cout << 1 << endl;
 
 	screens = new ScreenInfo[1];
 	focusedWorkspaces = new int[1];
 	detectScreens();
+	cout << 2 << endl;
 
 	int screenNum = DefaultScreen(dpy);
 	sW = DisplayWidth(dpy, screenNum);
 	sH = DisplayHeight(dpy, screenNum);
 
+	cout << 3 << endl;
 	XSetErrorHandler(OnXError);
 	XSelectInput(dpy, root, SubstructureRedirectMask | SubstructureNotifyMask | KeyPressMask | EnterWindowMask);
 
+	cout << 4 << endl;
 	XDefineCursor(dpy, root, XCreateFontCursor(dpy, XC_top_left_arrow));
 	//EWMH
 	initEWMH(&dpy, &root, cfg.workspaces.size(), cfg.workspaces);
 	setCurrentDesktop(1);
 
+	cout << 5 << endl;
 	for(int i = 1; i < cfg.numWS + 1; i++)
 	{
 		vector<int> v;
@@ -973,14 +996,6 @@ int main(int argc, char** argv)
 		frames.insert(pair<int, Frame>(i, rootFrame));
 		currFrameID++;
 	}
-	for(int i = 0; i < cfg.startupBashc; i++)
-	{
-		if(fork() == 0)
-		{
-			system((cfg.startupBash[i] + " > /dev/null 2> /dev/null").c_str());
-			exit(0);
-		}
-	}
 
 	XSetInputFocus(dpy, root, RevertToNone, CurrentTime);
 	XWarpPointer(dpy, root, root, 0, 0, 0, 0, 960, 540);
diff --git a/util.h b/util.h
index 666fb40..bc3cc6a 100644
--- a/util.h
+++ b/util.h
@@ -2,8 +2,15 @@
 
 #include <vector>
 #include <string>
+#include <X11/Xlib.h>
 
 #define evNames {0, 0, "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut", "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify", "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest", "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify", "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify", "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify", "ClientMessage", "MappingNotify", "GenericEvent", "LASTEvent"};
 
 
 std::vector<std::string> split (const std::string &s, char delim);
+
+
+struct Globals {
+	Display* dpy;
+	Window root;
+};
-- 
cgit v1.2.3


From e9cc5756dbb0a2d079a7b5e3438d79945f819df5 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Sat, 3 Jun 2023 21:30:05 +1200
Subject: feat: Keybind updates

Re added the ability to swap super and mod as a config parameter (the
~swapmods~) command).
Finally fixed keybinds sometimes not working because of numlock,
bitwise & with the modifiers I actually care about.
---
 commands.cpp | 20 ++------------------
 commands.h   |  2 --
 config       |  4 ++++
 config.cpp   |  7 +++++++
 config.h     |  3 +++
 keybinds.cpp | 22 +++++++++++++++++-----
 keybinds.h   |  5 ++++-
 main.cpp     | 11 ++++-------
 8 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index 09bdf62..c41536d 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -12,30 +12,15 @@
 
 using std::cout, std::endl, std::string, std::vector, std::tolower;
 
-const void CommandsModule::printHello(const CommandArg* argv)
-{
-	cout << "Hello" << endl;
-}
-
-const void CommandsModule::echo(const CommandArg* argv)
-{
-	cout << "Echo: '" << argv[0].str << '\'' << endl;
-}
-
 CommandsModule::CommandsModule()
 {
-	addCommand("printHello", &CommandsModule::printHello, 0, {}, this);
-	CommandArgType* args0 = new CommandArgType[1];
-	args0[0] = STR_REST;
-	addCommand("echo", &CommandsModule::echo, 1, args0, this);
 }
 CommandsModule::~CommandsModule()
 {
 	for(Command c : commandList)
 	{
-		// This is probably needed but its not working
-		//if(c.argc > 0)
-			//delete[] c.argTypes;
+		if(c.argc > 0)
+			delete[] c.argTypes;
 	}
 }
 
@@ -150,7 +135,6 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 
 void CommandsModule::runCommand(string command)
 {
-	cout << command << endl;
 	vector<string> split = splitCommand(command);
 	Command* cmd = lookupCommand(split[0]);
 	if(cmd == nullptr)
diff --git a/commands.h b/commands.h
index 92801bd..d7f2351 100644
--- a/commands.h
+++ b/commands.h
@@ -51,8 +51,6 @@ private:
 	std::vector<Command> commandList;
 	std::vector<std::string> splitCommand(std::string command);
 	CommandArg* getCommandArgs(std::vector<std::string>& args, const CommandArgType* argTypes, const int argc);
-	const void printHello(const CommandArg* argv);
-	const void echo(const CommandArg* argv);
 public:   
 	CommandsModule();
 	~CommandsModule();
diff --git a/config b/config
index 5eb0c4a..de761d3 100644
--- a/config
+++ b/config
@@ -1,4 +1,8 @@
 # This is a comment
+
+# Mainly used for testing
+swapmods
+
 bind mod+e exit
 bind mod+Return spawn kitty
 gaps 10
diff --git a/config.cpp b/config.cpp
index cff7a45..6ade520 100644
--- a/config.cpp
+++ b/config.cpp
@@ -45,6 +45,11 @@ const void Config::addWorkspaceCmd(const CommandArg* argv)
 	numWS++;
 }
 
+const void Config::swapSuperAltCmd(const CommandArg* argv)
+{
+	swapSuperAlt ^= true;
+}
+
 Config::Config(CommandsModule& commandsModule)
 	: commandsModule(commandsModule)
 {
@@ -53,6 +58,7 @@ Config::Config(CommandsModule& commandsModule)
 	commandsModule.addCommand("outergaps", &Config::outerGapsCmd, 1, {NUM}, this);
 	commandsModule.addCommand("logfile", &Config::logFileCmd, 1, {STR_REST}, this);
 	commandsModule.addCommand("addworkspace", &Config::addWorkspaceCmd, 2, {STR, NUM_ARR_REST}, this);
+	commandsModule.addCommand("swapmods", &Config::swapSuperAltCmd, 0, {}, this);
 }
 
 std::vector<Err> Config::reloadFile()
@@ -72,6 +78,7 @@ std::vector<Err> Config::loadFromFile(std::string path)
 	outerGaps = 3;
 	logFile = "/tmp/yatlog.txt";
 	numWS = 0;
+	swapSuperAlt = false;
 
 	//Probably need something for workspaces and binds too...
 
diff --git a/config.h b/config.h
index b02dc9e..452db9c 100644
--- a/config.h
+++ b/config.h
@@ -37,12 +37,15 @@ public:
 	int numWS;
 	bool loaded = false;
 
+	// Binds
+	bool swapSuperAlt;
 
 	// Config Commands
 	COMMAND(gapsCmd);
 	COMMAND(outerGapsCmd);
 	COMMAND(logFileCmd);
 	COMMAND(addWorkspaceCmd);
+	COMMAND(swapSuperAltCmd);
 
 private:
 	CommandsModule& commandsModule;
diff --git a/keybinds.cpp b/keybinds.cpp
index 30b3fd0..85e9e4e 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -10,9 +10,10 @@
 
 using std::string, std::cout, std::endl;
 
-KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Globals& globals)
+KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals)
 	:commandsModule(commandsModule),
-	globals(globals)
+	 globals(globals),
+	 cfg(cfg)
 {
 	CommandArgType* bindArgs = new CommandArgType[2];
 	bindArgs[0] = STR;
@@ -23,10 +24,15 @@ KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Globals& globals)
 const void KeybindsModule::handleKeypress(XKeyEvent e)
 {
 	if(e.same_screen!=1) return;
+	//cout << "Key Pressed" << endl;
+	//cout << "\tState: " << e.state << endl;
+	//cout << "\tCode: " <<  XKeysymToString(XKeycodeToKeysym(globals.dpy, e.keycode, 0)) << endl;
 	//updateMousePos();
+
+	const unsigned int masks = ShiftMask | ControlMask | Mod1Mask | Mod4Mask;
 	for(Keybind bind : binds)
 	{
-		if(bind.modifiers == e.state && bind.key == XKeycodeToKeysym(globals.dpy, e.keycode, 0))
+		if(bind.modifiers == (e.state & masks) && bind.key == XKeycodeToKeysym(globals.dpy, e.keycode, 0))
 		{
 			commandsModule.runCommand(bind.command);
 		}
@@ -48,11 +54,11 @@ const void KeybindsModule::bind(const CommandArg* argv)
 	{
 		if(key == "mod")
 		{
-			bind.modifiers |= Mod1Mask;
+			bind.modifiers |= Mod4Mask >> 3 * cfg.swapSuperAlt;
 		}
 		else if(key == "alt")
 		{
-			bind.modifiers |= Mod4Mask;
+			bind.modifiers |= Mod1Mask << 3 * cfg.swapSuperAlt;
 		}
 		else if(key == "shift")
 		{
@@ -74,7 +80,13 @@ const void KeybindsModule::bind(const CommandArg* argv)
 		}
 	}
 	bind.command = argv[1].str;
+	cout << bind.modifiers << endl;
 	KeyCode c = XKeysymToKeycode(globals.dpy, bind.key);
 	XGrabKey(globals.dpy, c, bind.modifiers, globals.root, False, GrabModeAsync, GrabModeAsync);
 	binds.push_back(bind);
 }
+
+const void KeybindsModule::clearKeybinds()
+{
+	XUngrabButton(globals.dpy, AnyKey, AnyModifier, globals.root);
+}
diff --git a/keybinds.h b/keybinds.h
index 43f6ef3..07d9aea 100644
--- a/keybinds.h
+++ b/keybinds.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "commands.h"
+#include "config.h"
 #include "util.h"
 
 struct Keybind {
@@ -18,12 +19,14 @@ struct Keybind {
 
 class KeybindsModule {
 public:
-	KeybindsModule(CommandsModule& commandsModule, Globals& globals);
+	KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals);
 	~KeybindsModule() = default;
 	const void bind(const CommandArg* argv);
 	const void handleKeypress(XKeyEvent e);
+	const void clearKeybinds();
 private:
 	std::vector<Keybind> binds;
 	CommandsModule& commandsModule;
+	Config& cfg;
 	Globals& globals;
 };
diff --git a/main.cpp b/main.cpp
index 034554c..e74634d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -51,7 +51,7 @@ Window& root = globals.root;
 
 CommandsModule commandsModule;
 Config cfg(commandsModule);
-KeybindsModule keybindsModule(commandsModule, globals);
+KeybindsModule keybindsModule(commandsModule, cfg, globals);
 
 int sW, sH;
 int bH;
@@ -527,6 +527,9 @@ const void reload(const CommandArg* argv)
 {
 	detectScreens();
 
+	//Clear keybinds
+	keybindsModule.clearKeybinds();
+	
 	//Load config again
 	vector<Err> cfgErr = cfg.reloadFile();
 	//Error check
@@ -964,31 +967,25 @@ int main(int argc, char** argv)
 	//Notifications
 	notify_init("YATwm");
 
-	cout << 0 << endl;
 	//Error check config
 	handleConfigErrs(cfgErr);
-	cout << 1 << endl;
 
 	screens = new ScreenInfo[1];
 	focusedWorkspaces = new int[1];
 	detectScreens();
-	cout << 2 << endl;
 
 	int screenNum = DefaultScreen(dpy);
 	sW = DisplayWidth(dpy, screenNum);
 	sH = DisplayHeight(dpy, screenNum);
 
-	cout << 3 << endl;
 	XSetErrorHandler(OnXError);
 	XSelectInput(dpy, root, SubstructureRedirectMask | SubstructureNotifyMask | KeyPressMask | EnterWindowMask);
 
-	cout << 4 << endl;
 	XDefineCursor(dpy, root, XCreateFontCursor(dpy, XC_top_left_arrow));
 	//EWMH
 	initEWMH(&dpy, &root, cfg.workspaces.size(), cfg.workspaces);
 	setCurrentDesktop(1);
 
-	cout << 5 << endl;
 	for(int i = 1; i < cfg.numWS + 1; i++)
 	{
 		vector<int> v;
-- 
cgit v1.2.3


From 0b539b0b0278f2d7c2b7629e6d28d8463cba2688 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Mon, 5 Jun 2023 20:35:32 +1200
Subject: Added a very basic config, and fixed some stuff

NOTE: for some reason toggling doesn't work anymore
---
 commands.cpp | 52 +++++++++++++++++++++++++++++++---------------------
 config       | 31 +++++++++++++++++++++++++++++++
 config.cpp   |  7 ++++++-
 keybinds.cpp |  6 +++---
 keybinds.h   |  3 ++-
 main.cpp     | 11 +++++++----
 6 files changed, 80 insertions(+), 30 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index c41536d..141de26 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -86,10 +86,9 @@ vector<string> CommandsModule::splitCommand(string command)
 	return v;
 }
 
-template <typename T>
-std::basic_string<T> lowercase(const std::basic_string<T>& s)
+string lowercase(string s)
 {
-    std::basic_string<T> s2 = s;
+    string s2 = s;
     std::transform(s2.begin(), s2.end(), s2.begin(), [](unsigned char c){ return std::tolower(c); });
     return s2;
 }
@@ -103,30 +102,41 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 		{
 			case STR: args[i-1].str = (char*)split[i].c_str(); break;
 			case NUM: args[i-1].num = std::stoi(split[i]); break;
-			case MOVDIR: args[i-1].dir = LEFT; break;
+			case MOVDIR:
+				{
+					if(lowercase(split[i]) == "up")
+						args[i-1].dir = UP;
+					else if(lowercase(split[i]) == "down")
+						args[i-1].dir = DOWN;
+					else if(lowercase(split[i]) == "left")
+						args[i-1].dir = LEFT;
+					else if(lowercase(split[i]) == "right")
+						args[i-1].dir = RIGHT;
+					break;
+				}
 			case STR_REST:
-			{
-				string rest = "";
-				for(int j = i; j < split.size(); j++)
 				{
-					rest += split[j];
-					if(j != split.size() - 1)
-						rest += " ";
+					string rest = "";
+					for(int j = i; j < split.size(); j++)
+					{
+						rest += split[j];
+						if(j != split.size() - 1)
+							rest += " ";
+					}
+					args[i-1].str = new char[rest.size()];
+					strcpy(args[i-1].str, rest.c_str());
+					return args;
 				}
-				args[i-1].str = new char[rest.size()];
-				strcpy(args[i-1].str, rest.c_str());
-				return args;
-			}
 			case NUM_ARR_REST:
-			{
-				int* rest = new int[split.size() - i];
-				for(int j = 0; j < split.size() - i; j++)
 				{
-					rest[j] = std::stoi(split[j + i]);
+					int* rest = new int[split.size() - i];
+					for(int j = 0; j < split.size() - i; j++)
+					{
+						rest[j] = std::stoi(split[j + i]);
+					}
+					args[i-1].numArr = {rest, (int) split.size() - i};
+					return args;
 				}
-				args[i-1].numArr = {rest, (int) split.size() - i};
-				return args;
-			}
 			default: cout << "UH OH SOMETHING IS VERY WRONG" << endl;
 		}
 	}
diff --git a/config b/config
index de761d3..b046b67 100644
--- a/config
+++ b/config
@@ -7,4 +7,35 @@ bind mod+e exit
 bind mod+Return spawn kitty
 gaps 10
 outergaps 10
+
+# Tiling
+bind mod+t toggle
+
+# Focus
+bind mod+h focChange left
+bind mod+j focChange down
+bind mod+k focChange up
+bind mod+l focChange right
+
+# Workspaces
 addworkspace "1: A" 1
+addworkspace "2: B" 1
+addworkspace "3: C" 1
+addworkspace "4: D" 1
+addworkspace "5: E" 1
+addworkspace "6: F" 2 1
+addworkspace "7: G" 2 1
+addworkspace "8: H" 2 1
+addworkspace "9: I" 2 1
+addworkspace "10: J" 2 1
+
+bind mod+1 changeWS 1
+bind mod+2 changeWS 2
+bind mod+3 changeWS 3
+bind mod+4 changeWS 4
+bind mod+5 changeWS 5
+bind mod+6 changeWS 6
+bind mod+7 changeWS 7
+bind mod+8 changeWS 8
+bind mod+9 changeWS 9
+bind mod+0 changeWS 10
diff --git a/config.cpp b/config.cpp
index 6ade520..b17f0e2 100644
--- a/config.cpp
+++ b/config.cpp
@@ -40,7 +40,10 @@ const void Config::logFileCmd(const CommandArg* argv)
 const void Config::addWorkspaceCmd(const CommandArg* argv)
 {
 	int* prefs = new int[argv[1].numArr.size];
-	memcpy(prefs, argv[1].numArr.arr, argv[1].numArr.size * sizeof(int));
+	for(int i = 0; i < argv[1].numArr.size; i++)
+	{
+		prefs[i] = argv[1].numArr.arr[i] - 1;
+	}
 	workspaces.push_back({argv[0].str, prefs, argv[1].numArr.size});
 	numWS++;
 }
@@ -87,6 +90,8 @@ std::vector<Err> Config::loadFromFile(std::string path)
 	std::ifstream config(path);
 	while(getline(config, cmd))
 	{
+		if(cmd.size() == 0)
+			continue;
 		if(cmd.at(0) == '#')
 			continue;
 		try
diff --git a/keybinds.cpp b/keybinds.cpp
index 85e9e4e..6e4abfd 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -10,7 +10,7 @@
 
 using std::string, std::cout, std::endl;
 
-KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals)
+KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals, void (*updateMousePos)())
 	:commandsModule(commandsModule),
 	 globals(globals),
 	 cfg(cfg)
@@ -19,6 +19,7 @@ KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Config& cfg, Glob
 	bindArgs[0] = STR;
 	bindArgs[1] = STR_REST;
 	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, bindArgs, this);
+	this->updateMousePos = updateMousePos;
 }
 
 const void KeybindsModule::handleKeypress(XKeyEvent e)
@@ -27,7 +28,7 @@ const void KeybindsModule::handleKeypress(XKeyEvent e)
 	//cout << "Key Pressed" << endl;
 	//cout << "\tState: " << e.state << endl;
 	//cout << "\tCode: " <<  XKeysymToString(XKeycodeToKeysym(globals.dpy, e.keycode, 0)) << endl;
-	//updateMousePos();
+	updateMousePos();
 
 	const unsigned int masks = ShiftMask | ControlMask | Mod1Mask | Mod4Mask;
 	for(Keybind bind : binds)
@@ -80,7 +81,6 @@ const void KeybindsModule::bind(const CommandArg* argv)
 		}
 	}
 	bind.command = argv[1].str;
-	cout << bind.modifiers << endl;
 	KeyCode c = XKeysymToKeycode(globals.dpy, bind.key);
 	XGrabKey(globals.dpy, c, bind.modifiers, globals.root, False, GrabModeAsync, GrabModeAsync);
 	binds.push_back(bind);
diff --git a/keybinds.h b/keybinds.h
index 07d9aea..686eaf8 100644
--- a/keybinds.h
+++ b/keybinds.h
@@ -19,7 +19,7 @@ struct Keybind {
 
 class KeybindsModule {
 public:
-	KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals);
+	KeybindsModule(CommandsModule& commandsModule, Config& cfg, Globals& globals, void (*updateMousePos)());
 	~KeybindsModule() = default;
 	const void bind(const CommandArg* argv);
 	const void handleKeypress(XKeyEvent e);
@@ -29,4 +29,5 @@ private:
 	CommandsModule& commandsModule;
 	Config& cfg;
 	Globals& globals;
+	void (*updateMousePos)();
 };
diff --git a/main.cpp b/main.cpp
index e74634d..2e1f0ad 100644
--- a/main.cpp
+++ b/main.cpp
@@ -47,11 +47,13 @@ std::ofstream yatlog;
 Globals globals;
 
 Display*& dpy = globals.dpy;
-Window& root = globals.root;
+Window &root = globals.root;
+
+void updateMousePos();
 
 CommandsModule commandsModule;
 Config cfg(commandsModule);
-KeybindsModule keybindsModule(commandsModule, cfg, globals);
+KeybindsModule keybindsModule(commandsModule, cfg, globals, &updateMousePos);
 
 int sW, sH;
 int bH;
@@ -82,7 +84,6 @@ int currWS = 1;
 // Usefull functions
 int FFCF(int sID);
 void detectScreens();
-void updateMousePos();
 void focusRoot(int root);
 void handleConfigErrs(vector<Err> cfgErrs);
 
@@ -270,7 +271,7 @@ void cWS(int newWS)
 
 	//log("Changing WS with keybind");
 
-	for(int i = 0; i < nscreens; i++)
+	for(int i = 0; i < cfg.workspaces[newWS - 1].screenPreferencesc; i++)
 	{
 		if(nscreens > cfg.workspaces[newWS - 1].screenPreferences[i])
 		{
@@ -304,6 +305,8 @@ void cWS(int newWS)
 	//log("Roots tiled");
 	XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
 
+	cout << focusedWorkspaces[0] << endl;
+
 	//EWMH
 	setCurrentDesktop(currWS);
 }
-- 
cgit v1.2.3


From 5f54adae7bc4edaf2c18383efe13ded233255509 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Fri, 16 Jun 2023 00:05:28 +1200
Subject: feat: Uses a backup config file and respects XDG

Uses config files in the order of `$XDG_CONFIG_HOME/YATwm/config`,
`$HOME/.config/YATwm/config`, then `/etc/YATwm/config`
---
 config       |  5 ++++-
 config.cpp   | 12 ++++++++++--
 keybinds.cpp |  3 ++-
 main.cpp     | 55 +++++++++++++++++++++++++++++++++++--------------------
 makefile     |  4 ++--
 util.h       |  4 ++--
 6 files changed, 55 insertions(+), 28 deletions(-)

diff --git a/config b/config
index b046b67..8ccdc1e 100644
--- a/config
+++ b/config
@@ -4,10 +4,13 @@
 swapmods
 
 bind mod+e exit
-bind mod+Return spawn kitty
+bind mod+Return spawn alacritty
+bind mod+k spawn kitty
 gaps 10
 outergaps 10
 
+bind mod+r reload
+
 # Tiling
 bind mod+t toggle
 
diff --git a/config.cpp b/config.cpp
index b17f0e2..5200a4b 100644
--- a/config.cpp
+++ b/config.cpp
@@ -74,20 +74,28 @@ std::vector<Err> Config::reloadFile()
 std::vector<Err> Config::loadFromFile(std::string path)
 {
 	std::vector<Err> errs;
-	
+
 	file = path;
+	
+	std::ifstream config(path);
+	if(!config.good())
+	{
+		config = std::ifstream("/etc/YATwm/config");
+		errs.push_back({CFG_ERR_FATAL, "Using default config: /etc/YATwm/config"});
+	}
+	
 	//Set defaults
 	gaps = 3;
 	outerGaps = 3;
 	logFile = "/tmp/yatlog.txt";
 	numWS = 0;
 	swapSuperAlt = false;
+	workspaces = std::vector<Workspace>();
 
 	//Probably need something for workspaces and binds too...
 
 	string cmd;
 	int line = 0;
-	std::ifstream config(path);
 	while(getline(config, cmd))
 	{
 		if(cmd.size() == 0)
diff --git a/keybinds.cpp b/keybinds.cpp
index 6e4abfd..3a431f0 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -33,7 +33,7 @@ const void KeybindsModule::handleKeypress(XKeyEvent e)
 	const unsigned int masks = ShiftMask | ControlMask | Mod1Mask | Mod4Mask;
 	for(Keybind bind : binds)
 	{
-		if(bind.modifiers == (e.state & masks) && bind.key == XKeycodeToKeysym(globals.dpy, e.keycode, 0))
+		if(bind.modifiers == (e.state & masks) && bind.key == XLookupKeysym(&e, 0))
 		{
 			commandsModule.runCommand(bind.command);
 		}
@@ -89,4 +89,5 @@ const void KeybindsModule::bind(const CommandArg* argv)
 const void KeybindsModule::clearKeybinds()
 {
 	XUngrabButton(globals.dpy, AnyKey, AnyModifier, globals.root);
+	binds = std::vector<Keybind>();
 }
diff --git a/main.cpp b/main.cpp
index 2e1f0ad..14e43b7 100644
--- a/main.cpp
+++ b/main.cpp
@@ -44,10 +44,10 @@ std::ofstream yatlog;
 
 #define log(x) yatlog << x << std::endl
 
-Globals globals;
+Display* dpy;
+Window root;
 
-Display*& dpy = globals.dpy;
-Window &root = globals.root;
+Globals globals = {dpy, root};
 
 void updateMousePos();
 
@@ -532,13 +532,14 @@ const void reload(const CommandArg* argv)
 
 	//Clear keybinds
 	keybindsModule.clearKeybinds();
-	
+
 	//Load config again
 	vector<Err> cfgErr = cfg.reloadFile();
 	//Error check
 	handleConfigErrs(cfgErr);
 
 	//Re tile
+	untileRoots();
 	tileRoots();
 }
 const void wsDump(const CommandArg* argv)
@@ -577,7 +578,10 @@ void configureRequest(XConfigureRequestEvent e)
 	changes.border_width = e.border_width;
 	changes.sibling = e.above;
 	changes.stack_mode = e.detail;
-	XConfigureWindow(dpy, e.window, e.value_mask, &changes);
+	XConfigureWindow(dpy, e.window, (unsigned int) e.value_mask, &changes);
+	log("Configure request: " << e.window);
+	//XSetInputFocus(dpy, e.window, RevertToNone, CurrentTime);
+	//tileRoots();
 }
 
 void mapRequest(XMapRequestEvent e)
@@ -656,7 +660,7 @@ void mapRequest(XMapRequestEvent e)
 
 	
 
-	XSetInputFocus(dpy, e.window, RevertToNone, CurrentTime);
+
 	XSelectInput(dpy, e.window, EnterWindowMask);
 	
 	//Make client
@@ -680,7 +684,7 @@ void mapRequest(XMapRequestEvent e)
 	status = getProp(e.window, "_NET_WM_STATE", &type, &data);
 	if(status == Success && type!=None && (((Atom*)data)[0] == XInternAtom(dpy, "_NET_WM_STATE_MODAL", false) || ((Atom*)data)[0] == XInternAtom(dpy, "_NET_WM_STATE_ABOVE", false)))
 	{
-		log("\tWindow floating");
+		cout << "Floating" << endl;
 		clients.find(c.ID)->second.floating = true;
 		frames.find(pID)->second.floatingFrameIDs.push_back(f.ID);
 		frames.insert(pair<int, Frame>(f.ID, f));
@@ -736,6 +740,7 @@ void mapRequest(XMapRequestEvent e)
 	updateClientList(clients);
 
 	//tile(currWS, outerGaps, outerGaps, sW - outerGaps*2, sH - outerGaps*2 - bH);
+	XSetInputFocus(dpy, e.window, RevertToNone, CurrentTime);
 	tileRoots();
 }
 
@@ -790,10 +795,10 @@ void destroyNotify(XDestroyWindowEvent e)
 void enterNotify(XEnterWindowEvent e)
 {
 	//log(e.xcrossing.x);
-	/* Cancel if crossing into root
-	if(e.xcrossing.window == root)
-		break;
-	*/
+	//Cancel if crossing into root
+	if(e.window == root)
+		return;
+	
 	XWindowAttributes attr;
 	XGetWindowAttributes(dpy, e.window, &attr);
 	int monitor = 0;
@@ -839,7 +844,10 @@ void clientMessage(XClientMessageEvent e)
 
 static int OnXError(Display* display, XErrorEvent* e)
 {
-	log("XError " << e->type);
+	char* error = new char[50];
+	XGetErrorText(dpy, e->type, error, 50);
+	log("XError " << error);
+	delete[] error;
 	return 0;
 }
 
@@ -935,8 +943,8 @@ int main(int argc, char** argv)
 	}
 	//Important init stuff
 	mX = mY = 0;
-	globals.dpy = XOpenDisplay(nullptr);
-	globals.root = Window(DefaultRootWindow(dpy));
+    dpy = XOpenDisplay(nullptr);
+    root = Window(DefaultRootWindow(dpy));
 
 	// Adding commands
 	commandsModule.addCommand("exit", exit, 0, {});
@@ -953,11 +961,18 @@ int main(int argc, char** argv)
 	commandsModule.addCommand("nextMonitor", nextMonitor, 0, {});
 
 	//Config
-	std::string home = getenv("HOME");
-	std::string pathAfterHome = "/.config/YATwm/config.toml";
-	std::string file = home + pathAfterHome;
-	// Err cfgErr = cfg.loadFromFile(file);
-	std::vector<Err> cfgErr = cfg.loadFromFile("config");
+	std::vector<Err> cfgErr;
+	
+	char* confDir = getenv("XDG_CONFIG_HOME");
+	if(confDir != NULL)
+	{
+		cfgErr = cfg.loadFromFile(string(confDir) + "/YATwm/config");
+	}
+	else
+	{
+		string home = getenv("HOME");
+		cfgErr = cfg.loadFromFile(home + "/.config/YATwm/config");
+	}
 
 	//Log
 	yatlog.open(cfg.logFile, std::ios_base::app);
@@ -981,7 +996,7 @@ int main(int argc, char** argv)
 	sW = DisplayWidth(dpy, screenNum);
 	sH = DisplayHeight(dpy, screenNum);
 
-	XSetErrorHandler(OnXError);
+	//XSetErrorHandler(OnXError);
 	XSelectInput(dpy, root, SubstructureRedirectMask | SubstructureNotifyMask | KeyPressMask | EnterWindowMask);
 
 	XDefineCursor(dpy, root, XCreateFontCursor(dpy, XC_top_left_arrow));
diff --git a/makefile b/makefile
index 01e6b5d..df4304a 100644
--- a/makefile
+++ b/makefile
@@ -18,9 +18,9 @@ $(OBJS_DIR)/%.o : $(SOURCE_DIR)/%.cpp
 	$(CXX) $(CXXFLAGS) -c $< -o $@
 
 i: $(EXEC)
-	sudo install -D $(EXEC) $(INSTALL_DIR)usr/bin/$(EXEC)
+	sudo install -D -m 755 $(EXEC) $(INSTALL_DIR)usr/bin/$(EXEC)
 	sudo install -D -m 644 yat.desktop $(INSTALL_DIR)usr/share/xsessions/yat.desktop
-	sudo install -D -m 644 config.toml $(INSTALL_DIR)etc/YATwm/config.toml
+	sudo install -D -m 644 config $(INSTALL_DIR)etc/YATwm/config
 install: i
 r:
 	sudo rm $(INSTALL_DIR)usr/bin/$(EXEC)
diff --git a/util.h b/util.h
index bc3cc6a..bdc45d8 100644
--- a/util.h
+++ b/util.h
@@ -11,6 +11,6 @@ std::vector<std::string> split (const std::string &s, char delim);
 
 
 struct Globals {
-	Display* dpy;
-	Window root;
+	Display*& dpy;
+	Window& root;
 };
-- 
cgit v1.2.3


From d4196b2476909e2c92ece6363eee7f450d74be5f Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Fri, 16 Jun 2023 17:33:41 +1200
Subject: feat: Error checking for command args

The command arguements now handle errors.
---
 commands.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 47 insertions(+), 4 deletions(-)

diff --git a/commands.cpp b/commands.cpp
index 141de26..4e8e01b 100644
--- a/commands.cpp
+++ b/commands.cpp
@@ -4,6 +4,7 @@
 #include <cctype>
 #include <iostream>
 #include <algorithm>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
@@ -101,7 +102,19 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 		switch(argTypes[i-1])
 		{
 			case STR: args[i-1].str = (char*)split[i].c_str(); break;
-			case NUM: args[i-1].num = std::stoi(split[i]); break;
+			case NUM:
+				{
+					try
+					{
+						args[i-1].num = std::stoi(split[i]);
+						break;
+					}
+					catch(std::invalid_argument e)
+					{
+						delete[] args;
+						throw Err(CMD_ERR_WRONG_ARGS, split[i] + " is not a number!");
+					}
+				}
 			case MOVDIR:
 				{
 					if(lowercase(split[i]) == "up")
@@ -112,6 +125,11 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 						args[i-1].dir = LEFT;
 					else if(lowercase(split[i]) == "right")
 						args[i-1].dir = RIGHT;
+					else
+					{
+						delete[] args;
+						throw Err(CMD_ERR_WRONG_ARGS, split[i] + " is not a direction!");
+					}
 					break;
 				}
 			case STR_REST:
@@ -132,7 +150,16 @@ CommandArg* CommandsModule::getCommandArgs(vector<string>& split, const CommandA
 					int* rest = new int[split.size() - i];
 					for(int j = 0; j < split.size() - i; j++)
 					{
-						rest[j] = std::stoi(split[j + i]);
+						try
+						{
+							rest[j] = std::stoi(split[j + i]);
+						}
+						catch(std::invalid_argument e)
+						{
+							delete[] rest;
+							delete[] args;
+							throw Err(CMD_ERR_WRONG_ARGS, split[i] + " is not a number!");
+						}
 					}
 					args[i-1].numArr = {rest, (int) split.size() - i};
 					return args;
@@ -151,7 +178,15 @@ void CommandsModule::runCommand(string command)
 		throw Err(CMD_ERR_NOT_FOUND, split[0] + " is not a valid command name");
 	if(cmd->argc > split.size() - 1)
 		throw Err(CMD_ERR_WRONG_ARGS, command + " is the wrong args");
-	CommandArg* args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	CommandArg* args;
+	try
+	{
+		args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	}
+	catch(Err e)
+	{
+		throw e;
+	}
 	try
 	{
 		if(cmd->module == nullptr)
@@ -185,7 +220,15 @@ Err CommandsModule::checkCommand(string command)
 		return Err(CMD_ERR_NOT_FOUND, split[0] + " is not a valid command name");
 	if(cmd->argc > split.size())
 		return Err(CMD_ERR_WRONG_ARGS, command + " is the wrong args");
-	CommandArg* args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	CommandArg* args;
+	try
+	{
+		args = getCommandArgs(split, cmd->argTypes, cmd->argc);
+	}
+	catch(Err e)
+	{
+		return e;
+	}
 	for(int i = 0; i < cmd->argc; i++)
 	{
 		if(cmd->argTypes[i] == STR_REST || cmd->argTypes[i] == NUM_ARR_REST)
-- 
cgit v1.2.3


From 557faa2603d33d6f6a8b7baa9c9f7891bfcb8d30 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Sun, 18 Jun 2023 21:31:41 +1200
Subject: feat: Updated readme

Updated the readme and added a default config file.
---
 config       |  13 +-
 config.cpp   |   4 +-
 keybinds.cpp |   5 +-
 main.cpp     |   7 +
 readme.html  | 470 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 readme.org   | 100 +++++++++----
 6 files changed, 563 insertions(+), 36 deletions(-)
 create mode 100644 readme.html

diff --git a/config b/config
index 8ccdc1e..f97bb04 100644
--- a/config
+++ b/config
@@ -1,15 +1,18 @@
 # This is a comment
 
 # Mainly used for testing
-swapmods
+# swapmods
 
-bind mod+e exit
+bind mod+shift+e exit
 bind mod+Return spawn alacritty
-bind mod+k spawn kitty
+bind mod+c spawn firefox
+bind mod+x spawn loginctl lock-session
+bind mod+shift+x bashSpawn loginctl lock-session && systemctl suspend
 gaps 10
 outergaps 10
 
-bind mod+r reload
+bind mod+shift+r reload
+bind mod+q kill
 
 # Tiling
 bind mod+t toggle
@@ -42,3 +45,5 @@ bind mod+7 changeWS 7
 bind mod+8 changeWS 8
 bind mod+9 changeWS 9
 bind mod+0 changeWS 10
+
+spawnOnce xss-lock --transfer-sleep-lock -- i3lock -et --nofork
\ No newline at end of file
diff --git a/config.cpp b/config.cpp
index 5200a4b..27ecb6a 100644
--- a/config.cpp
+++ b/config.cpp
@@ -85,8 +85,8 @@ std::vector<Err> Config::loadFromFile(std::string path)
 	}
 	
 	//Set defaults
-	gaps = 3;
-	outerGaps = 3;
+	gaps = 10;
+	outerGaps = 10;
 	logFile = "/tmp/yatlog.txt";
 	numWS = 0;
 	swapSuperAlt = false;
diff --git a/keybinds.cpp b/keybinds.cpp
index 3a431f0..64d3fc8 100644
--- a/keybinds.cpp
+++ b/keybinds.cpp
@@ -15,10 +15,7 @@ KeybindsModule::KeybindsModule(CommandsModule& commandsModule, Config& cfg, Glob
 	 globals(globals),
 	 cfg(cfg)
 {
-	CommandArgType* bindArgs = new CommandArgType[2];
-	bindArgs[0] = STR;
-	bindArgs[1] = STR_REST;
-	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, bindArgs, this);
+	commandsModule.addCommand("bind", &KeybindsModule::bind, 2, {STR, STR_REST}, this);
 	this->updateMousePos = updateMousePos;
 }
 
diff --git a/main.cpp b/main.cpp
index 14e43b7..d4502dd 100644
--- a/main.cpp
+++ b/main.cpp
@@ -224,6 +224,12 @@ const void spawn(const CommandArg* argv)
 		exit(0);
 	}
 }
+const void spawnOnce(const CommandArg* argv)
+{
+	if(cfg.loaded)
+		return;
+	else spawn(argv);
+}
 const void toggle(const CommandArg* argv)
 {
 	nextDir = nextDir = (nextDir==horizontal)? vertical : horizontal;
@@ -949,6 +955,7 @@ int main(int argc, char** argv)
 	// Adding commands
 	commandsModule.addCommand("exit", exit, 0, {});
 	commandsModule.addCommand("spawn", spawn, 1, {STR_REST});
+	commandsModule.addCommand("spawnOnce", spawnOnce, 1, {STR_REST});
 	commandsModule.addCommand("toggle", toggle, 0, {});
 	commandsModule.addCommand("kill", kill, 0, {});
 	commandsModule.addCommand("changeWS", changeWS, 1, {NUM});
diff --git a/readme.html b/readme.html
new file mode 100644
index 0000000..38a81bc
--- /dev/null
+++ b/readme.html
@@ -0,0 +1,470 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+<!-- 2023-06-18 Sun 21:31 -->
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>YATwm</title>
+<meta name="generator" content="Org Mode" />
+<style>
+  #content { max-width: 60em; margin: auto; }
+  .title  { text-align: center;
+             margin-bottom: .2em; }
+  .subtitle { text-align: center;
+              font-size: medium;
+              font-weight: bold;
+              margin-top:0; }
+  .todo   { font-family: monospace; color: red; }
+  .done   { font-family: monospace; color: green; }
+  .priority { font-family: monospace; color: orange; }
+  .tag    { background-color: #eee; font-family: monospace;
+            padding: 2px; font-size: 80%; font-weight: normal; }
+  .timestamp { color: #bebebe; }
+  .timestamp-kwd { color: #5f9ea0; }
+  .org-right  { margin-left: auto; margin-right: 0px;  text-align: right; }
+  .org-left   { margin-left: 0px;  margin-right: auto; text-align: left; }
+  .org-center { margin-left: auto; margin-right: auto; text-align: center; }
+  .underline { text-decoration: underline; }
+  #postamble p, #preamble p { font-size: 90%; margin: .2em; }
+  p.verse { margin-left: 3%; }
+  pre {
+    border: 1px solid #e6e6e6;
+    border-radius: 3px;
+    background-color: #f2f2f2;
+    padding: 8pt;
+    font-family: monospace;
+    overflow: auto;
+    margin: 1.2em;
+  }
+  pre.src {
+    position: relative;
+    overflow: auto;
+  }
+  pre.src:before {
+    display: none;
+    position: absolute;
+    top: -8px;
+    right: 12px;
+    padding: 3px;
+    color: #555;
+    background-color: #f2f2f299;
+  }
+  pre.src:hover:before { display: inline; margin-top: 14px;}
+  /* Languages per Org manual */
+  pre.src-asymptote:before { content: 'Asymptote'; }
+  pre.src-awk:before { content: 'Awk'; }
+  pre.src-authinfo::before { content: 'Authinfo'; }
+  pre.src-C:before { content: 'C'; }
+  /* pre.src-C++ doesn't work in CSS */
+  pre.src-clojure:before { content: 'Clojure'; }
+  pre.src-css:before { content: 'CSS'; }
+  pre.src-D:before { content: 'D'; }
+  pre.src-ditaa:before { content: 'ditaa'; }
+  pre.src-dot:before { content: 'Graphviz'; }
+  pre.src-calc:before { content: 'Emacs Calc'; }
+  pre.src-emacs-lisp:before { content: 'Emacs Lisp'; }
+  pre.src-fortran:before { content: 'Fortran'; }
+  pre.src-gnuplot:before { content: 'gnuplot'; }
+  pre.src-haskell:before { content: 'Haskell'; }
+  pre.src-hledger:before { content: 'hledger'; }
+  pre.src-java:before { content: 'Java'; }
+  pre.src-js:before { content: 'Javascript'; }
+  pre.src-latex:before { content: 'LaTeX'; }
+  pre.src-ledger:before { content: 'Ledger'; }
+  pre.src-lisp:before { content: 'Lisp'; }
+  pre.src-lilypond:before { content: 'Lilypond'; }
+  pre.src-lua:before { content: 'Lua'; }
+  pre.src-matlab:before { content: 'MATLAB'; }
+  pre.src-mscgen:before { content: 'Mscgen'; }
+  pre.src-ocaml:before { content: 'Objective Caml'; }
+  pre.src-octave:before { content: 'Octave'; }
+  pre.src-org:before { content: 'Org mode'; }
+  pre.src-oz:before { content: 'OZ'; }
+  pre.src-plantuml:before { content: 'Plantuml'; }
+  pre.src-processing:before { content: 'Processing.js'; }
+  pre.src-python:before { content: 'Python'; }
+  pre.src-R:before { content: 'R'; }
+  pre.src-ruby:before { content: 'Ruby'; }
+  pre.src-sass:before { content: 'Sass'; }
+  pre.src-scheme:before { content: 'Scheme'; }
+  pre.src-screen:before { content: 'Gnu Screen'; }
+  pre.src-sed:before { content: 'Sed'; }
+  pre.src-sh:before { content: 'shell'; }
+  pre.src-sql:before { content: 'SQL'; }
+  pre.src-sqlite:before { content: 'SQLite'; }
+  /* additional languages in org.el's org-babel-load-languages alist */
+  pre.src-forth:before { content: 'Forth'; }
+  pre.src-io:before { content: 'IO'; }
+  pre.src-J:before { content: 'J'; }
+  pre.src-makefile:before { content: 'Makefile'; }
+  pre.src-maxima:before { content: 'Maxima'; }
+  pre.src-perl:before { content: 'Perl'; }
+  pre.src-picolisp:before { content: 'Pico Lisp'; }
+  pre.src-scala:before { content: 'Scala'; }
+  pre.src-shell:before { content: 'Shell Script'; }
+  pre.src-ebnf2ps:before { content: 'ebfn2ps'; }
+  /* additional language identifiers per "defun org-babel-execute"
+       in ob-*.el */
+  pre.src-cpp:before  { content: 'C++'; }
+  pre.src-abc:before  { content: 'ABC'; }
+  pre.src-coq:before  { content: 'Coq'; }
+  pre.src-groovy:before  { content: 'Groovy'; }
+  /* additional language identifiers from org-babel-shell-names in
+     ob-shell.el: ob-shell is the only babel language using a lambda to put
+     the execution function name together. */
+  pre.src-bash:before  { content: 'bash'; }
+  pre.src-csh:before  { content: 'csh'; }
+  pre.src-ash:before  { content: 'ash'; }
+  pre.src-dash:before  { content: 'dash'; }
+  pre.src-ksh:before  { content: 'ksh'; }
+  pre.src-mksh:before  { content: 'mksh'; }
+  pre.src-posh:before  { content: 'posh'; }
+  /* Additional Emacs modes also supported by the LaTeX listings package */
+  pre.src-ada:before { content: 'Ada'; }
+  pre.src-asm:before { content: 'Assembler'; }
+  pre.src-caml:before { content: 'Caml'; }
+  pre.src-delphi:before { content: 'Delphi'; }
+  pre.src-html:before { content: 'HTML'; }
+  pre.src-idl:before { content: 'IDL'; }
+  pre.src-mercury:before { content: 'Mercury'; }
+  pre.src-metapost:before { content: 'MetaPost'; }
+  pre.src-modula-2:before { content: 'Modula-2'; }
+  pre.src-pascal:before { content: 'Pascal'; }
+  pre.src-ps:before { content: 'PostScript'; }
+  pre.src-prolog:before { content: 'Prolog'; }
+  pre.src-simula:before { content: 'Simula'; }
+  pre.src-tcl:before { content: 'tcl'; }
+  pre.src-tex:before { content: 'TeX'; }
+  pre.src-plain-tex:before { content: 'Plain TeX'; }
+  pre.src-verilog:before { content: 'Verilog'; }
+  pre.src-vhdl:before { content: 'VHDL'; }
+  pre.src-xml:before { content: 'XML'; }
+  pre.src-nxml:before { content: 'XML'; }
+  /* add a generic configuration mode; LaTeX export needs an additional
+     (add-to-list 'org-latex-listings-langs '(conf " ")) in .emacs */
+  pre.src-conf:before { content: 'Configuration File'; }
+
+  table { border-collapse:collapse; }
+  caption.t-above { caption-side: top; }
+  caption.t-bottom { caption-side: bottom; }
+  td, th { vertical-align:top;  }
+  th.org-right  { text-align: center;  }
+  th.org-left   { text-align: center;   }
+  th.org-center { text-align: center; }
+  td.org-right  { text-align: right;  }
+  td.org-left   { text-align: left;   }
+  td.org-center { text-align: center; }
+  dt { font-weight: bold; }
+  .footpara { display: inline; }
+  .footdef  { margin-bottom: 1em; }
+  .figure { padding: 1em; }
+  .figure p { text-align: center; }
+  .equation-container {
+    display: table;
+    text-align: center;
+    width: 100%;
+  }
+  .equation {
+    vertical-align: middle;
+  }
+  .equation-label {
+    display: table-cell;
+    text-align: right;
+    vertical-align: middle;
+  }
+  .inlinetask {
+    padding: 10px;
+    border: 2px solid gray;
+    margin: 10px;
+    background: #ffffcc;
+  }
+  #org-div-home-and-up
+   { text-align: right; font-size: 70%; white-space: nowrap; }
+  textarea { overflow-x: auto; }
+  .linenr { font-size: smaller }
+  .code-highlighted { background-color: #ffff00; }
+  .org-info-js_info-navigation { border-style: none; }
+  #org-info-js_console-label
+    { font-size: 10px; font-weight: bold; white-space: nowrap; }
+  .org-info-js_search-highlight
+    { background-color: #ffff00; color: #000000; font-weight: bold; }
+  .org-svg { }
+</style>
+</head>
+<body>
+<div id="content" class="content">
+<h1 class="title">YATwm</h1>
+<div id="table-of-contents" role="doc-toc">
+<h2>Table of Contents</h2>
+<div id="text-table-of-contents" role="doc-toc">
+<ul>
+<li><a href="#org4543ad1">1. This config is best read in Emacs!</a></li>
+<li><a href="#org8c9779d">2. Disclaimer: This is still very much in beta</a></li>
+<li><a href="#orgd6a129e">3. Usage instructions</a>
+<ul>
+<li><a href="#org71e2ad0">3.1. Installation</a>
+<ul>
+<li><a href="#org4c27fc8">3.1.1. Pre reqs</a></li>
+<li><a href="#org4738b76">3.1.2. Installing and removing</a></li>
+</ul>
+</li>
+<li><a href="#org48288fb">3.2. Config</a>
+<ul>
+<li><a href="#org78ac98a">3.2.1. Syntax</a></li>
+<li><a href="#org70839ee">3.2.2. General</a></li>
+<li><a href="#org7a3dcb5">3.2.3. Workspaces</a></li>
+<li><a href="#org47d354f">3.2.4. Keybinds</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a href="#org328b75f">4. Credits</a></li>
+</ul>
+</div>
+</div>
+<div id="outline-container-org4543ad1" class="outline-2">
+<h2 id="org4543ad1"><span class="section-number-2">1.</span> This config is best read in Emacs!</h2>
+</div>
+
+<div id="outline-container-org8c9779d" class="outline-2">
+<h2 id="org8c9779d"><span class="section-number-2">2.</span> Disclaimer: This is still very much in beta</h2>
+<div class="outline-text-2" id="text-2">
+<p>
+This only just works, multiple monitors aren't supported and floating windows cannot move and there is no resizing. Many features are just hacked together and are likely to break. However, it is just about usable so if you really want to try then go for it! (feel free to make an issue if you have any questions).<br />
+</p>
+</div>
+</div>
+
+<div id="outline-container-orgd6a129e" class="outline-2">
+<h2 id="orgd6a129e"><span class="section-number-2">3.</span> Usage instructions</h2>
+<div class="outline-text-2" id="text-3">
+</div>
+<div id="outline-container-org71e2ad0" class="outline-3">
+<h3 id="org71e2ad0"><span class="section-number-3">3.1.</span> Installation</h3>
+<div class="outline-text-3" id="text-3-1">
+</div>
+<div id="outline-container-org4c27fc8" class="outline-4">
+<h4 id="org4c27fc8"><span class="section-number-4">3.1.1.</span> Pre reqs</h4>
+<div class="outline-text-4" id="text-3-1-1">
+<ul class="org-ul">
+<li><code>Xlib</code> and <code>g++</code> and <code>libnotify</code> to build the program<br /></li>
+<li><code>Xephyr</code> for the test script<br /></li>
+<li><code>rofi</code>, <code>alacritty</code>, and <code>i3lock</code> for the default config<br />
+<ul class="org-ul">
+<li>The current default config is currently just the configuration that I want to use (this will likely change)<br /></li>
+</ul></li>
+</ul>
+</div>
+</div>
+<div id="outline-container-org4738b76" class="outline-4">
+<h4 id="org4738b76"><span class="section-number-4">3.1.2.</span> Installing and removing</h4>
+<div class="outline-text-4" id="text-3-1-2">
+<ul class="org-ul">
+<li><code>make i</code> or <code>make install</code> to install<br /></li>
+<li><code>make r</code> or <code>make remove</code> to remove<br /></li>
+<li><code>./test</code> to test<br /></li>
+</ul>
+</div>
+</div>
+</div>
+<div id="outline-container-org48288fb" class="outline-3">
+<h3 id="org48288fb"><span class="section-number-3">3.2.</span> Config</h3>
+<div class="outline-text-3" id="text-3-2">
+<p>
+You can configure YATwm with the config file in <code>$HOME/.config/YATwm/config</code> or <code>$XDG_CONFIG_HOME/YATwm/config</code> if you have that set. I have provided an example config file in the project dir that has all the variables set to their defaults (this will also be installed to <code>/etc/YATwm/config</code>.<br />
+It should alert you with a notification if you have an error, and put the error your log file. If the whole file is missing then it will use the default in <code>/etc/YATwm/config</code>.<br />
+</p>
+</div>
+<div id="outline-container-org78ac98a" class="outline-4">
+<h4 id="org78ac98a"><span class="section-number-4">3.2.1.</span> Syntax</h4>
+<div class="outline-text-4" id="text-3-2-1">
+<p>
+The config file is a list of commands. Each command should be on a new line. For example, to set the gaps you would use the <code>gaps</code> command like this <code>gaps 10</code> (make sure this is all there is on that line). This says to call the command <code>gaps</code> with the arguments of <code>10</code>. Commands can have multiple arguments and these should be separated with a space, if you want a space in one of the arguments then wrap the arg in quotes, e.g. <code>addWorkspace "1: A" 1</code>, here the arguments are <code>1: A</code> and <code>1</code>.<br />
+</p>
+</div>
+<ol class="org-ol">
+<li><a id="orgf44e4fe"></a>Command arg types<br />
+<div class="outline-text-5" id="text-3-2-1-1">
+<ul class="org-ul">
+<li>String: this is just some text, this can be wrapped in quotes if you want a space in it.<br /></li>
+<li>String rest: This will only ever be the final argument. This just takes the rest of the line as a string, so you can use spaces without needing quotes.<br /></li>
+<li>Number: This is a number, with the digits 0-9.<br /></li>
+<li>Number array rest: This will only ever be the final argument. This takes the rest of the line as a list of number, separated with spaces, e.g. <code>2 1 3</code>.<br /></li>
+<li>Direction: This is one of the cardinal directions listed below.<br />
+<ul class="org-ul">
+<li>left<br /></li>
+<li>right<br /></li>
+<li>up<br /></li>
+<li>down<br /></li>
+</ul></li>
+</ul>
+</div>
+</li>
+<li><a id="org8b55f35"></a>List of commands<br />
+<div class="outline-text-5" id="text-3-2-1-2">
+<ul class="org-ul">
+<li>exit: shuts down YATwm<br /></li>
+<li>spawn: Spawns an application using <code>execvp</code><br />
+<ul class="org-ul">
+<li>String rest: what to spawn, first word is the command, and following words are arguments (note: due to limitations with the command system you cannot use quotes)<br /></li>
+</ul></li>
+<li>spawnOnce: Same as spawn but only runs on the first load of the config file<br />
+<ul class="org-ul">
+<li>String rest: what to spawn, first word is the command, and following words are arguments (note: due to limitations with the command system you cannot use quotes)<br /></li>
+</ul></li>
+<li>toggle: Changes the tiling direction for the next window<br /></li>
+<li>kill: Kills the focused window<br /></li>
+<li>changeWS: changes to a different workspace<br />
+<ul class="org-ul">
+<li>Number: Which workspace to change to, starts at 1 for first workspace.<br /></li>
+</ul></li>
+<li>wToWS: moves a window to a workspace<br />
+<ul class="org-ul">
+<li>Number: Which workspace to move the window to, starts at 1 for first workspace.<br /></li>
+</ul></li>
+<li>focChange: Changes the focus in a direction<br />
+<ul class="org-ul">
+<li>Direction: Which direction to focus in<br /></li>
+</ul></li>
+<li>bashSpawn: Spawns something uses <code>system</code> (your shell)<br />
+<ul class="org-ul">
+<li>String rest: A string which gets sent to bash (note: due to limitations with the command system you cannot use quotes)<br /></li>
+</ul></li>
+<li>bashSpawnOnce: Same as bashSpawn but only runs on the first load of the config file<br />
+<ul class="org-ul">
+<li>String rest: A string which gets sent to bash (note: due to limitations with the command system you cannot use quotes)<br /></li>
+</ul></li>
+<li>reload: Reloads YATwm, this reloads the config file and re runs the monitor detection, and will unmap and remap all windows to refresh them.<br /></li>
+<li>nextMonitor: Focuses the next monitor, wraps around.<br /></li>
+<li>gaps: Sets the size of the inner gaps, margins around each window (this ends up looking doubled as each window has it)<br />
+<ul class="org-ul">
+<li>Number: The size in pixels<br /></li>
+</ul></li>
+<li>outergaps: Sets the size of the outer gaps, distance for windows and the edge of the output (add this to the inner gaps to get distance between window and edge of output)<br />
+<ul class="org-ul">
+<li>Number: The size in pixels<br /></li>
+</ul></li>
+<li>logfile: The file to write the log to<br />
+<ul class="org-ul">
+<li>String: The name of the file<br /></li>
+</ul></li>
+<li>swapmods: Swaps super and alt for keybinds<br /></li>
+<li>addworkspace: Adds a workspace (note: This doesn't work very well with refreshes, I'd suggest not messing with it, but you can probably change the names of workspace without anything breaking)<br />
+<ul class="org-ul">
+<li>String: The name of the workspace<br /></li>
+<li>Number array rest: The monitor preferences. This is which monitor it should appear on, first (primary) monitor is one. E.g. <code>2 1</code> to appear on the second monitor first, but if that isn't plugged in then use the first.<br /></li>
+</ul></li>
+<li>bind: Binds a key to a command<br />
+<ul class="org-ul">
+<li>String: The key bind, modifiers and keys are separated with +, e.g. <code>mod+x</code><br /></li>
+<li>String rest: The command to run<br /></li>
+</ul></li>
+<li>wsDump: This is a command for testing, you probably don't want to use it<br /></li>
+</ul>
+</div>
+</li>
+</ol>
+</div>
+<div id="outline-container-org70839ee" class="outline-4">
+<h4 id="org70839ee"><span class="section-number-4">3.2.2.</span> General</h4>
+<div class="outline-text-4" id="text-3-2-2">
+<p>
+You can change either the inner gaps (padding around each window - so double it for space between windows), or the outer gaps (padding around the display - add to inner gaps to get space between window and screen edges).<br />
+They can be changed with the commands <code>gaps</code> and <code>outerGaps</code> in the config file (default <code>10</code> for both).<br />
+YATwm also keeps a log file, the location of this file can be changed with the command <code>logFile</code> (default <code>/tmp/yatlog.txt</code>).<br />
+</p>
+</div>
+</div>
+
+<div id="outline-container-org7a3dcb5" class="outline-4">
+<h4 id="org7a3dcb5"><span class="section-number-4">3.2.3.</span> Workspaces</h4>
+<div class="outline-text-4" id="text-3-2-3">
+<p>
+You can add workspace with the command <code>addworkspace</code> in the config file.<br />
+</p>
+<pre class="example">
+addworkspace "1: A" 1
+addworkspace "2: B" 1
+</pre>
+<p>
+Defaults workspace are listed below (these are the args for the addworkspace command):<br />
+</p>
+<ol class="org-ol">
+<li>"1: A" 1<br /></li>
+<li>"2: B" 1<br /></li>
+<li>"3: C" 1<br /></li>
+<li>"4: D" 1<br /></li>
+<li>"5: E" 1<br /></li>
+<li>"6: F" 2 1<br /></li>
+<li>"7: G" 2 1<br /></li>
+<li>"8: H" 2 1<br /></li>
+<li>"9: I" 2 1<br /></li>
+<li>"10: J" 2 1<br /></li>
+</ol>
+</div>
+</div>
+<div id="outline-container-org47d354f" class="outline-4">
+<h4 id="org47d354f"><span class="section-number-4">3.2.4.</span> Keybinds</h4>
+<div class="outline-text-4" id="text-3-2-4">
+<p>
+Current keybinds (these can all be edited):<br />
+</p>
+<ul class="org-ul">
+<li><code>mod + e</code>     : exit<br /></li>
+<li><code>mod + t</code>     : change next tile direction<br /></li>
+<li><code>mod + q</code>     : quit focused window<br /></li>
+<li><code>mod + shift + r</code>   : reload WM (rechecks monitors)<br /></li>
+<li><code>mod + direction</code>   : change focus in direction (vim keybinds)<br /></li>
+<li><code>mod + shift + direction</code> : move window in direction (vim keybinds)<br /></li>
+<li><code>mod + enter</code>    : alacritty<br /></li>
+<li><code>mod + d</code>     : rofi<br /></li>
+<li><code>mod + c</code>     : firefox<br /></li>
+<li><code>mod + x</code>     : lock<br /></li>
+<li><code>mod + shift + x</code>   : lock and sleep<br /></li>
+<li><code>mod + (num)</code>    : switch to workspace (num) - currently only for 1-10 but you can add more<br /></li>
+<li><code>mod + shift + (num)</code>  : move window to workspace (num) - currently only for 1-10 but you can add more<br /></li>
+</ul>
+<p>
+(mod is super, and the direction keys are h, j, k, l - left, down, up, right respectively like vim)<br />
+</p>
+
+<p>
+You can use the command <code>swapmods</code> to make <code>mod</code> act as <code>alt</code> and <code>alt</code> act as <code>mod</code>.<br />
+</p>
+
+<p>
+To add new keybinds use the bind command:<br />
+</p>
+<pre class="example">
+bind mod+q kill
+bind mod+shift+x bashSpawn loginctl lock-session &amp;&amp; systemctl suspend
+</pre>
+<p>
+Commands are executed going down the list and multiple commands with the same keybind and modifiers will all be executed<br />
+</p>
+</div>
+</div>
+</div>
+</div>
+
+<div id="outline-container-org328b75f" class="outline-2">
+<h2 id="org328b75f"><span class="section-number-2">4.</span> Credits</h2>
+<div class="outline-text-2" id="text-4">
+<p>
+Catwm (<a href="https://github.com/pyknite/catwm">https://github.com/pyknite/catwm</a>)<br />
+</p>
+
+<p>
+basic<sub>wm</sub> (<a href="https://github.com/jichu4n/basic_wm">https://github.com/jichu4n/basic_wm</a>)<br />
+</p>
+</div>
+</div>
+</div>
+<div id="postamble" class="status">
+<p class="date">Created: 2023-06-18 Sun 21:31</p>
+<p class="validation"><a href="https://validator.w3.org/check?uri=referer">Validate</a></p>
+</div>
+</body>
+</html>
diff --git a/readme.org b/readme.org
index 46a4753..4ccee0d 100644
--- a/readme.org
+++ b/readme.org
@@ -1,6 +1,6 @@
 #+TITLE: YATwm
 #+OPTIONS: \n:t
-* This config is best read in emacs!
+* This config is best read in Emacs!
 
 * Disclaimer: This is still very much in beta
 This only just works, multiple monitors aren't supported and floating windows cannot move and there is no resizing. Many features are just hacked together and are likely to break. However, it is just about usable so if you really want to try then go for it! (feel free to make an issue if you have any questions).
@@ -10,58 +10,106 @@ This only just works, multiple monitors aren't supported and floating windows ca
 *** Pre reqs
 - ~Xlib~ and ~g++~ and ~libnotify~ to build the program
 - ~Xephyr~ for the test script
-- ~rofi~, ~alacritty~, ~picom~, ~feh~, ~polybar~, ~qutebrowser~ and ~i3lock~ for the default config
+- ~rofi~, ~alacritty~, and ~i3lock~ for the default config
 	- The current default config is currently just the configuration that I want to use (this will likely change)
 *** Installing and removing
 - ~make i~ or ~make install~ to install
 - ~make r~ or ~make remove~ to remove
 - ~./test~ to test
 ** Config
-You can configure YATwm with the config file in ~$HOME/.config/YATwm/config.toml~. I have provided an example config file in this directory that has all the variables set to their defaults.
-It should alert you with a notification if you have an error, and put the error your log file. It will just use default values if you didn't provide them or provided invalid values (apart from keybinds and startupBash entries, which will just be skipped if invalid (but defaults will be used if the whole array is missing).
-*** Startup
-Add a bash command to the ~startupBash~ string array in your config and it will execute on startup.
+You can configure YATwm with the config file in ~$HOME/.config/YATwm/config~ or ~$XDG_CONFIG_HOME/YATwm/config~ if you have that set. I have provided an example config file in the project dir that has all the variables set to their defaults (this will also be installed to ~/etc/YATwm/config~.
+It should alert you with a notification if you have an error, and put the error your log file. If the whole file is missing then it will use the default in ~/etc/YATwm/config~.
+*** Syntax
+The config file is a list of commands. Each command should be on a new line. For example, to set the gaps you would use the ~gaps~ command like this ~gaps 10~ (make sure this is all there is on that line). This says to call the command ~gaps~ with the arguments of ~10~. Commands can have multiple arguments and these should be separated with a space, if you want a space in one of the arguments then wrap the arg in quotes, e.g. ~addWorkspace "1: A" 1~, here the arguments are ~1: A~ and ~1~.
+**** Command arg types
+- String: this is just some text, this can be wrapped in quotes if you want a space in it.
+- String rest: This will only ever be the final argument. This just takes the rest of the line as a string, so you can use spaces without needing quotes.
+- Number: This is a number, with the digits 0-9.
+- Number array rest: This will only ever be the final argument. This takes the rest of the line as a list of number, separated with spaces, e.g. ~2 1 3~.
+- Direction: This is one of the cardinal directions listed below.
+  - left
+  - right
+  - up
+  - down
+**** List of commands
+- exit: shuts down YATwm
+- spawn: Spawns an application using ~execvp~
+  - String rest: what to spawn, first word is the command, and following words are arguments (note: due to limitations with the command system you cannot use quotes)
+- spawnOnce: Same as spawn but only runs on the first load of the config file
+  - String rest: what to spawn, first word is the command, and following words are arguments (note: due to limitations with the command system you cannot use quotes)
+- toggle: Changes the tiling direction for the next window
+- kill: Kills the focused window
+- changeWS: changes to a different workspace
+  - Number: Which workspace to change to, starts at 1 for first workspace.
+- wToWS: moves a window to a workspace
+  - Number: Which workspace to move the window to, starts at 1 for first workspace.
+- focChange: Changes the focus in a direction
+  - Direction: Which direction to focus in
+- bashSpawn: Spawns something uses ~system~ (your shell)
+  - String rest: A string which gets sent to bash (note: due to limitations with the command system you cannot use quotes)
+- bashSpawnOnce: Same as bashSpawn but only runs on the first load of the config file
+  - String rest: A string which gets sent to bash (note: due to limitations with the command system you cannot use quotes)
+- reload: Reloads YATwm, this reloads the config file and re runs the monitor detection, and will unmap and remap all windows to refresh them.
+- nextMonitor: Focuses the next monitor, wraps around.
+- gaps: Sets the size of the inner gaps, margins around each window (this ends up looking doubled as each window has it)
+  - Number: The size in pixels
+- outergaps: Sets the size of the outer gaps, distance for windows and the edge of the output (add this to the inner gaps to get distance between window and edge of output)
+  - Number: The size in pixels
+- logfile: The file to write the log to
+  - String: The name of the file
+- swapmods: Swaps super and alt for keybinds
+- addworkspace: Adds a workspace (note: This doesn't work very well with refreshes, I'd suggest not messing with it, but you can probably change the names of workspace without anything breaking)
+  - String: The name of the workspace
+  - Number array rest: The monitor preferences. This is which monitor it should appear on, first (primary) monitor is one. E.g. ~2 1~ to appear on the second monitor first, but if that isn't plugged in then use the first.
+- bind: Binds a key to a command
+  - String: The key bind, modifiers and keys are separated with +, e.g. ~mod+x~
+  - String rest: The command to run
+- wsDump: This is a command for testing, you probably don't want to use it
 *** General
 You can change either the inner gaps (padding around each window - so double it for space between windows), or the outer gaps (padding around the display - add to inner gaps to get space between window and screen edges).
-They can be changed with the integers ~gaps~ and ~outerGaps~ in the config file.
-YATwm also keeps a log file, the location of this file can be changed with the string ~logFile~.
+They can be changed with the commands ~gaps~ and ~outerGaps~ in the config file (default ~10~ for both).
+YATwm also keeps a log file, the location of this file can be changed with the command ~logFile~ (default ~/tmp/yatlog.txt~).
 
 *** Workspaces
-You can change the number of workspaces by editing ~numWS~ in the config file (this will likely change), and the names by editing ~workspaceNames~. You can think of workspaces as virtual desktops. You can change the preference of workspaces by editing the ~screenPreferences~ array. It orders the screens with 0 being the first monitor and they go up from there. The number coming first for each workspace will be the highest priority and other ones will be used if that monitor is not detected. All preference arrays should end in 0. You can use maxMonitors to set how many is the max amount of monitors you would have plugged in (this will likely change).
+You can add workspace with the command ~addworkspace~ in the config file.
+#+begin_src
+addworkspace "1: A" 1
+addworkspace "2: B" 1
+#+end_src
+Defaults workspace are listed below (these are the args for the addworkspace command):
+1. "1: A" 1
+2. "2: B" 1
+3. "3: C" 1
+4. "4: D" 1
+5. "5: E" 1
+6. "6: F" 2 1
+7. "7: G" 2 1
+8. "8: H" 2 1
+9. "9: I" 2 1
+10. "10: J" 2 1
 *** Keybinds
 Current keybinds (these can all be edited): 
 - ~mod + e~					: exit
 - ~mod + t~					: change next tile direction
 - ~mod + q~					: quit focused window
 - ~mod + shift + r~			: reload WM (rechecks monitors)
-- ~mod + direction~			: change focus in direction
-- ~mod + shift + direction~	: move window in direction
+- ~mod + direction~			: change focus in direction (vim keybinds)
+- ~mod + shift + direction~	: move window in direction (vim keybinds)
 - ~mod + enter~				: alacritty
 - ~mod + d~					: rofi
 - ~mod + c~					: firefox
 - ~mod + x~					: lock
 - ~mod + shift + x~			: lock and sleep
-- ~mod + p~					: log testing stuff
 - ~mod + (num)~				: switch to workspace (num) - currently only for 1-10 but you can add more
 - ~mod + shift + (num)~		: move window to workspace (num) - currently only for 1-10 but you can add more
 (mod is super, and the direction keys are h, j, k, l - left, down, up, right respectively like vim)
 
-You can use the variable ~swapSuperAlt~ to make ~mod~ act as ~alt~ and ~alt~ act as ~mod~.
+You can use the command ~swapmods~ to make ~mod~ act as ~alt~ and ~alt~ act as ~mod~.
 
-To add new keybinds create a new entry in the Keybinds.key array:
-#+begin_src
-[[Keybinds.key]]
-bind = "bind"
-func = "func"
-args = args
-#+end_src
-Args can be either a string or a number, directions are strings.
-e.g.
+To add new keybinds use the bind command:
 #+begin_src
-[[Keybinds.key]]
-bind = "mod+shift+j"
-func = "wMove"
-args = "Down"
+bind mod+q kill
+bind mod+shift+x bashSpawn loginctl lock-session && systemctl suspend
 #+end_src
 Commands are executed going down the list and multiple commands with the same keybind and modifiers will all be executed
 
-- 
cgit v1.2.3


From 185015b39b8db953b8034f29724ef03de09e7ea1 Mon Sep 17 00:00:00 2001
From: BossCode45 <human.cyborg42@gmail.com>
Date: Mon, 19 Jun 2023 10:41:30 +1200
Subject: fixup: Cleaning up old files

---
 config.cpp.old | 364 ---------------------------------------------------------
 config.h.old   |  93 ---------------
 2 files changed, 457 deletions(-)
 delete mode 100644 config.cpp.old
 delete mode 100644 config.h.old

diff --git a/config.cpp.old b/config.cpp.old
deleted file mode 100644
index 74ba0b0..0000000
--- a/config.cpp.old
+++ /dev/null
@@ -1,364 +0,0 @@
-#include "config.h"
-
-#include "error.h"
-#include "toml++/toml.hpp"
-#include "util.h"
-
-#include <X11/X.h>
-#include <X11/Xlib.h>
-
-#include <string>
-#include <map>
-
-//Just for testing
-#include <iostream>
-#include <vector>
-
-using std::map, std::string, std::to_string;
-
-// For testing
-using std::cout, std::endl, std::cerr;
-
-map<string, void(*) (const KeyArg arg)> funcNameMap = {
-	{"exit", exit},
-	{"spawn", spawn},
-	{"toggle", toggle},
-	{"kill", kill},
-	{"changeWS", changeWS},
-	{"wToWS", wToWS},
-	{"focChange", focChange},
-	{"wMove", wMove},
-	{"bashSpawn", bashSpawn},
-	{"reload", reload},
-	{"wsDump", wsDump},
-	{"nextMonitor", nextMonitor},
-};
-
-
-Config::Config()
-{
-}
-
-string to_string(string s)
-{
-	return s;
-}
-string to_string(bool b)
-{
-	if(b)
-		return "true";
-	else
-		return "false";
-}
-
-template <typename T>
-T Config::getValue(string path, Err* err)
-{
-	std::optional<T> tblVal = tbl.at_path(path).value<T>();
-	if(tblVal)
-		return *tblVal;
-	else
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		T val = *defaults.at_path(path).value<T>();
-		err->errorMessage += "\n\tValue for " + path + " is invalid, using default (" + to_string(val) + ")";
-		return val;
-	}
-}
-
-void Config::loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err)
-{
-	if(!tbl["Workspaces"]["workspaceNames"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tworkspaceNames invalid array, using defaults";
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	workspaceNamesc = tbl["Workspaces"]["workspaceNames"].as_array()->size();
-	workspaceNames = new string[workspaceNamesc];
-	for(int i = 0; i < workspaceNamesc; i++)
-	{
-		auto element = tbl["Workspaces"]["workspaceNames"][i].value<string>();
-		if(element)
-			workspaceNames[i] = *element;
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\nelement " + to_string(i) + " in workspaceNames invalid, using defaults";
-			delete[] workspaceNames;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-	}
-	if(!tbl["Workspaces"]["screenPreferences"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nscreenPreferences invalid array, using default";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferencesc = tbl["Workspaces"]["screenPreferences"].as_array()->size();
-	if(screenPreferencesc != workspaceNamesc)
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\nworkspaceNames and screenPreferences aren't the same length, using defaults";
-		delete[] workspaceNames;
-		return loadWorkspaceArrays(defaults, defaults, err);
-	}
-	screenPreferences = new int*[screenPreferencesc];
-	for(int i = 0; i < screenPreferencesc; i++)
-	{
-		if(!tbl["Workspaces"]["screenPreferences"][i].as_array())
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\telement " + to_string(i) + " in screenPreferences in invalid, using defaults";
-			delete[] workspaceNames;
-			for(int k = 0; k < i; k++)
-			{
-				delete[] screenPreferences[k];
-			}
-			delete[] screenPreferences;
-			return loadWorkspaceArrays(defaults, defaults, err);
-		}
-		int* wsScreens = new int[maxMonitors];
-		for(int j = 0; j < maxMonitors; j++)
-		{
-			if(tbl["Workspaces"]["screenPreferences"][i].as_array()->size() <= j)
-			{
-				wsScreens[j] = 0;
-				continue;
-			}
-			auto element = tbl["Workspaces"]["screenPreferences"][i][j].value<int>();
-			if(element)
-				wsScreens[j] = *element;
-			else
-			{
-				err->code = ERR_CFG_NON_FATAL;
-				err->errorMessage += "\telement " + to_string(i) + " " + to_string(j) + " in screenPreferences in invalid, using defaults";
-				delete[] workspaceNames;
-				for(int k = 0; k <= i; k++)
-				{
-					delete[] screenPreferences[k];
-				}
-				delete[] screenPreferences;
-				return loadWorkspaceArrays(defaults, defaults, err);
-			}
-		}
-		screenPreferences[i] = wsScreens;
-	}
-}
-
-void Config::loadStartupBash(toml::table tbl, toml::table defaults, Err* err)
-{
-	if(!tbl["Startup"]["startupBash"].as_array())
-	{
-		err->code = ERR_CFG_NON_FATAL;
-		err->errorMessage += "\n\tstartupBash array invalid, using default";
-		return loadStartupBash(defaults, defaults, err);
-	}
-	startupBashc = tbl["Startup"]["startupBash"].as_array()->size();
-	std::vector<string> startupBash;
-	for(int i = 0; i < startupBashc; i++)
-	{
-		auto element = tbl["Startup"]["startupBash"][i].value<string>();
-		if(element)
-			startupBash.push_back(*element);
-		else
-		{
-			err->code = ERR_CFG_NON_FATAL;
-			err->errorMessage += "\n\tstartupBash element " + to_string(i) + " invalid, skipping";
-		}
-	}
-	startupBashc = startupBash.size();
-	this->startupBash = new string[startupBashc];
-	for(int i = 0; i < startupBash.size(); i++)
-	{
-		this->startupBash[i] = startupBash[i];
-	}
-}
-
-Err Config::reload()
-{
-	if(!loaded)
-		return {ERR_CFG_FATAL, "Path not set yet, call loadFromFile before reload"};
-	return loadFromFile(path);
-}
-
-Err Config::loadFromFile(string path)
-{
-	if(loaded)
-	{
-		free();
-	}
-	loaded = true;
-	this->path = path;
-	Err err;
-	err.code = NOERR;
-	err.errorMessage = "";
-	defaults = toml::parse_file("/etc/YATwm/config.toml");
-	try
-	{
-		tbl = toml::parse_file(path);
-	}
-	catch (const toml::parse_error& parseErr)
-	{
-		err.code = ERR_CFG_FATAL;
-		string description = (string) parseErr.description();
-		string startCol = std::to_string(parseErr.source().begin.column);
-		string startLine = std::to_string(parseErr.source().begin.line);
-		string endCol = std::to_string(parseErr.source().end.column);
-		string endLine = std::to_string(parseErr.source().end.line);
-		string pos =  "Line " + startLine;
-		string what = parseErr.what();
-		err.errorMessage += "\n\t" + description + "\t(" + pos + ")" + "\n\tUsing /etc/YATwm/config.toml instead";
-		tbl = defaults;
-	}
-
-	//Startup
-	loadStartupBash(tbl, defaults, &err);
-
-	//Main
-	gaps = getValue<int>("Main.gaps", &err);
-	outerGaps = getValue<int>("Main.outerGaps", &err);
-	logFile = getValue<string>("Main.logFile", &err);
-
-	//Workspaces
-	numWS = getValue<int>("Workspaces.numWS", &err);
-	maxMonitors = getValue<int>("Workspaces.maxMonitors", &err);
-	loadWorkspaceArrays(tbl, defaults, &err);
-	
-	//Keybinds
-	bool swapSuperAlt = getValue<bool>("Keybinds.swapSuperAlt", &err);
-
-	toml::node_view<toml::node> bindsArr = tbl["Keybinds"]["key"];
-	if(!bindsArr.is_array())
-	{
-		err.code = ERR_CFG_NON_FATAL;
-		err.errorMessage += "\n\tBinds array not valid, using default";
-		bindsArr = defaults["Keybinds"]["key"];
-	}
-	std::vector<KeyBind> keyBinds;
-	bindsc = bindsArr.as_array()->size();
-	for(int i = 0; i < bindsc; i++)
-	{
-		KeyBind bind;
-		bind.modifiers = 0;
-		const std::optional<string> potentialBindString = bindsArr[i]["bind"].value<string>();
-		string bindString;
-		if(potentialBindString)
-			bindString = *potentialBindString;
-		else
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
-			continue;
-		}
-		std::vector<string> keys = split(bindString, '+');
-		for(string key : keys)
-		{
-			if(key == "mod")
-			{
-				if(!swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "alt")
-			{
-				if(swapSuperAlt)
-					bind.modifiers |= Mod4Mask;
-				else
-					bind.modifiers |= Mod1Mask;
-			}
-			else if(key == "shift")
-			{
-				bind.modifiers |= ShiftMask;
-			}
-			else if(key == "control")
-			{
-				bind.modifiers |= ControlMask;
-			}
-			else
-			{
-				bind.keysym = XStringToKeysym(key.c_str());
-				if(bind.keysym == NoSymbol)
-				{
-					err.code = ERR_CFG_NON_FATAL;
-					err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the bind string is invalid";
-					continue;
-				}
-			}
-		}
-		std::optional<string> potentialFuncString = bindsArr[i]["func"].value<string>();
-		string funcString;
-		if(potentialFuncString)
-			funcString = *potentialFuncString;
-		else
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
-		}
-		if(funcNameMap.count(funcString) == 0)
-		{
-			err.code = ERR_CFG_NON_FATAL;
-			err.errorMessage += "\n\tSkipping element " + to_string(i) + " of binds as the func string is invalid";
-			continue;
-		}
-		void(* func) (const KeyArg arg) = funcNameMap.find(funcString)->second;
-		bind.func = func;
-
-		auto args = bindsArr[i]["args"];
-		if(args.is<int64_t>())
-		{
-			int num = *args.value<int>();
-			bind.args = {.num = num};
-		}
-		else if(args.is<string>())
-		{
-			string str = (string)*args.value<string>();
-			if(str == "Up")
-				bind.args = {.dir = Up};
-			else if (str == "Down")
-				bind.args = {.dir = Down};
-			else if (str == "Left")
-				bind.args = {.dir = Left};
-			else if (str == "Right")
-				bind.args = {.dir = Right};
-			else
-			{
-				bind.args = {.str = strdup(str.c_str())};
-			}
-		}
-		else
-		{
-			bind.args = {NULL};
-		}
-		keyBinds.push_back(bind);
-	}
-	bindsc = keyBinds.size();
-	binds = new KeyBind[bindsc];
-	for(int i = 0; i < bindsc; i++)
-	{
-		binds[i] = keyBinds[i];
-	}
-	if(err.code != NOERR)
-		err.errorMessage = err.errorMessage.substr(1);
-	return err;
-}
-
-Config::~Config()
-{
-	free();
-}
-void Config::free()
-{
-	delete[] startupBash;
-	delete[] workspaceNames;
-	for(int i = 0; i < screenPreferencesc; i++)
-	{
-		delete[] screenPreferences[i];
-	}
-	delete[] screenPreferences;
-	delete[] binds;
-	loaded = false;
-}
diff --git a/config.h.old b/config.h.old
deleted file mode 100644
index 31005e7..0000000
--- a/config.h.old
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "error.h"
-
-#include <toml++/toml.hpp>
-
-#include <X11/X.h>
-#include <X11/keysym.h>
-
-#include <string>
-
-enum MoveDir
-{
-	Up,
-	Right,
-	Down,
-	Left
-};
-
-typedef union
-{
-	char* str;
-	int num;
-	MoveDir dir;
-} KeyArg;
-
-struct KeyBind
-{
-	unsigned int modifiers;
-	KeySym keysym;
-	void(* func) (const KeyArg arg);
-	KeyArg args;
-};
-
-//Keybind commands
-#define KEYCOM(X) \
-	void X (const KeyArg arg)
-KEYCOM(exit);
-KEYCOM(spawn);
-KEYCOM(toggle);
-KEYCOM(kill);
-KEYCOM(changeWS);
-KEYCOM(wToWS);
-KEYCOM(focChange);
-KEYCOM(wMove);
-KEYCOM(bashSpawn);
-KEYCOM(reload);
-KEYCOM(wsDump);
-KEYCOM(nextMonitor);
-
-class Config
-{   
-	public:
-		Config();
-		~Config();
-		void free();
-	
-		Err loadFromFile(std::string path);
-		Err reload();
-
-		// Startup
-		std::string* startupBash;
-		int startupBashc;
-
-		// Main
-		int gaps;
-		int outerGaps;
-		std::string logFile;
-
-		// Workspaces
-		int numWS;
-		std::string* workspaceNames;
-		int workspaceNamesc;
-		int maxMonitors;
-		int** screenPreferences;
-		int screenPreferencesc;
-
-		// Keybinds
-		KeyBind* binds;
-		int bindsc;
-	private:
-		template <typename T>
-		T getValue(std::string path, Err* err);
-
-		void loadWorkspaceArrays(toml::table tbl, toml::table defaults, Err* err);
-		void loadStartupBash(toml::table tbl, toml::table defaults, Err* err);
-
-		toml::table tbl;
-		toml::table defaults;
-
-		bool loaded = false;
-		std::string path;
-};
-- 
cgit v1.2.3