Merge pull request #25 from ne-foss-org/nebuild-patches-deref

[CHORE] Patching TOML manifest parser to avoid null deref.

1 files changed, 1037 insertions, 1059 deletions

diff --git a/vendor/toml++/impl/node.hpp b/vendor/toml++/impl/node.hpp
index e4e316a..3ed1429 100644
--- a/vendor/toml++/impl/node.hpp
+++ b/vendor/toml++/impl/node.hpp
@@ -1,754 +1,733 @@
-//# This file is a part of toml++ and is subject to the the terms of the MIT license.
-//# Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
-//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
-// SPDX-License-Identifier: MIT
+// # This file is a part of toml++ and is subject to the the terms of the MIT license.
+// # Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
+// # See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
+//  SPDX-License-Identifier: MIT
 #pragma once
 
-#include "std_utility.hpp"
 #include "forward_declarations.hpp"
-#include "source_region.hpp"
 #include "header_start.hpp"
+#include "source_region.hpp"
+#include "std_utility.hpp"
 
-TOML_NAMESPACE_START
-{
-	/// \brief	A TOML node.
-	///
-	/// \detail A parsed TOML document forms a tree made up of tables, arrays and values.
-	/// 		This type is the base of each of those, providing a lot of the polymorphic plumbing.
-	class TOML_ABSTRACT_INTERFACE TOML_EXPORTED_CLASS node
-	{
-	  private:
-		/// \cond
-
-		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));
-		}
-
-		/// \endcond
-
-	  public:
-		TOML_EXPORTED_MEMBER_FUNCTION
-		virtual ~node() noexcept;
-
-		/// \name Type checks
-		/// @{
-
-		/// \brief	Checks if a node contains values/elements of only one type.
-		///
-		/// \detail \cpp
-		/// auto cfg = toml::parse("arr = [ 1, 2, 3, 4.0 ]");
-		/// toml::array& arr = *cfg["arr"].as_array();
-		///
-		/// toml::node* nonmatch{};
-		/// if (arr.is_homogeneous(toml::node_type::integer, nonmatch))
-		/// 	std::cout << "array was homogeneous"sv << "\n";
-		/// else
-		/// 	std::cout << "array was not homogeneous!\n"
-		/// 	<< "first non-match was a "sv << nonmatch->type() << " at " << nonmatch->source() << "\n";
-		/// \ecpp
-		///
-		/// \out
-		/// array was not homogeneous!
-		///	first non-match was a floating-point at line 1, column 18
-		/// \eout
-		///
-		/// \param	ntype	A TOML node type. <br>
-		/// 				\conditional_return{toml::node_type::none}
-		///					"is every element the same type?"
-		/// 				\conditional_return{Anything else}
-		///					"is every element one of these?"
-		///
-		/// \param first_nonmatch	Reference to a pointer in which the address of the first non-matching element
-		/// 						will be stored if the return value is false.
-		///
-		/// \returns	True if the node was homogeneous.
-		///
-		/// \remarks	Always returns `false` for empty tables and arrays.
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept = 0;
-
-		/// \brief	Checks if a node contains values/elements of only one type (const overload).
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept = 0;
-
-		/// \brief	Checks if the node contains values/elements of only one type.
-		///
-		/// \detail \cpp
-		/// auto arr = toml::array{ 1, 2, 3 };
-		/// std::cout << "homogenous: "sv << arr.is_homogeneous(toml::node_type::none) << "\n";
-		/// std::cout << "all floats: "sv << arr.is_homogeneous(toml::node_type::floating_point) << "\n";
-		/// std::cout << "all arrays: "sv << arr.is_homogeneous(toml::node_type::array) << "\n";
-		/// std::cout << "all ints:   "sv << arr.is_homogeneous(toml::node_type::integer) << "\n";
-		/// \ecpp
-		///
-		/// \out
-		/// homogeneous: true
-		/// all floats:  false
-		/// all arrays:  false
-		/// all ints:    true
-		/// \eout
-		///
-		/// \param	ntype	A TOML node type. <br>
-		/// 				\conditional_return{toml::node_type::none}
-		///					"is every element the same type?"
-		/// 				\conditional_return{Anything else}
-		///					"is every element one of these?"
-		///
-		/// \returns	True if the node was homogeneous.
-		///
-		/// \remarks	Always returns `false` for empty tables and arrays.
-		TOML_PURE_GETTER
-		virtual bool is_homogeneous(node_type ntype) const noexcept = 0;
-
-		/// \brief	Checks if the node contains values/elements of only one type.
-		///
-		/// \detail \cpp
-		/// auto arr = toml::array{ 1, 2, 3 };
-		/// std::cout << "homogenous:   "sv << arr.is_homogeneous() << "\n";
-		/// std::cout << "all doubles:  "sv << arr.is_homogeneous<double>() << "\n";
-		/// std::cout << "all arrays:   "sv << arr.is_homogeneous<toml::array>() << "\n";
-		/// std::cout << "all integers: "sv << arr.is_homogeneous<int64_t>() << "\n";
-		/// \ecpp
-		///
-		/// \out
-		/// homogeneous: true
-		/// all floats:  false
-		/// all arrays:  false
-		/// all ints:    true
-		/// \eout
-		///
-		/// \tparam	ElemType	A TOML node or value type. <br>
-		/// 					\conditional_return{Left as `void`}
-		///						"is every element the same type?" <br>
-		/// 					\conditional_return{Explicitly specified}
-		///						"is every element a T?"
-		///
-		/// \returns	True if the node was homogeneous.
-		///
-		/// \remarks	Always returns `false` for empty tables and arrays.
-		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>);
-		}
-
-		/// \brief	Returns the node's type identifier.
-		TOML_PURE_GETTER
-		virtual node_type type() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a table.
-		TOML_PURE_GETTER
-		virtual bool is_table() const noexcept = 0;
-
-		/// \brief	Returns true if this node is an array.
-		TOML_PURE_GETTER
-		virtual bool is_array() const noexcept = 0;
-
-		/// \brief	Returns true if this node is an array containing only tables.
-		TOML_PURE_GETTER
-		virtual bool is_array_of_tables() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a value.
-		TOML_PURE_GETTER
-		virtual bool is_value() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a string value.
-		TOML_PURE_GETTER
-		virtual bool is_string() const noexcept = 0;
-
-		/// \brief	Returns true if this node is an integer value.
-		TOML_PURE_GETTER
-		virtual bool is_integer() const noexcept = 0;
-
-		/// \brief	Returns true if this node is an floating-point value.
-		TOML_PURE_GETTER
-		virtual bool is_floating_point() const noexcept = 0;
-
-		/// \brief	Returns true if this node is an integer or floating-point value.
-		TOML_PURE_GETTER
-		virtual bool is_number() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a boolean value.
-		TOML_PURE_GETTER
-		virtual bool is_boolean() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a local date value.
-		TOML_PURE_GETTER
-		virtual bool is_date() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a local time value.
-		TOML_PURE_GETTER
-		virtual bool is_time() const noexcept = 0;
-
-		/// \brief	Returns true if this node is a date-time value.
-		TOML_PURE_GETTER
-		virtual bool is_date_time() const noexcept = 0;
-
-		/// \brief	Checks if a node is a specific type.
-		///
-		/// \tparam	T	A TOML node or value type.
-		///
-		/// \returns	Returns true if this node is an instance of the specified type.
-		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();
-		}
-
-		/// @}
-
-		/// \name Type casts
-		/// @{
-
-		/// \brief	Returns a pointer to the node as a toml::table, if it is one.
-		TOML_PURE_GETTER
-		virtual table* as_table() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::array, if it is one.
-		TOML_PURE_GETTER
-		virtual array* as_array() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<std::string>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<std::string>* as_string() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<int64_t>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<int64_t>* as_integer() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<double>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<double>* as_floating_point() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<bool>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<bool>* as_boolean() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<toml::date>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<date>* as_date() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<toml::time>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<time>* as_time() noexcept = 0;
-
-		/// \brief	Returns a pointer to the node as a toml::value<toml::date_time>, if it is one.
-		TOML_PURE_GETTER
-		virtual toml::value<date_time>* as_date_time() noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::table, if it is one.
-		TOML_PURE_GETTER
-		virtual const table* as_table() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::array, if it is one.
-		TOML_PURE_GETTER
-		virtual const array* as_array() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<std::string>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<std::string>* as_string() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<int64_t>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<int64_t>* as_integer() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<double>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<double>* as_floating_point() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<bool>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<bool>* as_boolean() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::date>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<date>* as_date() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::time>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<time>* as_time() const noexcept = 0;
-
-		/// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::date_time>, if it is one.
-		TOML_PURE_GETTER
-		virtual const toml::value<date_time>* as_date_time() const noexcept = 0;
-
-		/// \brief	Gets a pointer to the node as a more specific node type.
-		///
-		/// \details \cpp
-		///
-		/// toml::value<int64_t>* int_value = node->as<int64_t>();
-		/// toml::table* tbl = node->as<toml::table>();
-		/// if (int_value)
-		///		std::cout << "Node is a value<int64_t>\n";
-		/// else if (tbl)
-		///		std::cout << "Node is a table\n";
-		///
-		///	// fully-qualified value node types also work (useful for template code):
-		///	toml::value<int64_t>* int_value2 = node->as<toml::value<int64_t>>();
-		/// if (int_value2)
-		///		std::cout << "Node is a value<int64_t>\n";
-		/// \ecpp
-		///
-		/// \tparam	T	The node type or TOML value type to cast to.
-		///
-		/// \returns	A pointer to the node as the given type, or nullptr if it was a different type.
-		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();
-		}
-
-		/// \brief	Gets a pointer to the node as a more specific node type (const overload).
-		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();
-		}
-
-		/// @}
-
-		/// \name Value retrieval
-		/// @{
-
-		/// \brief	Gets the value contained by this node.
-		///
-		/// \detail This function has 'exact' retrieval semantics; the only return value types allowed are the
-		/// 		TOML native value types, or types that can losslessly represent a native value type (e.g.
-		/// 		std::wstring on Windows).
-		///
-		/// \tparam	T	One of the native TOML value types, or a type capable of losslessly representing one.
-		///
-		/// \returns	The underlying value if the node was a value of the
-		/// 			matching type (or losslessly convertible to it), or an empty optional.
-		///
-		/// \see node::value()
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		/// \brief	Gets the value contained by this node.
-		///
-		/// \detail This function has 'permissive' retrieval semantics; some value types are allowed
-		/// 		to convert to others (e.g. retrieving a boolean as an integer), and the specified return value
-		/// 		type can be any type where a reasonable conversion from a native TOML value exists
-		/// 		(e.g. std::wstring on Windows). If the source value cannot be represented by
-		/// 		the destination type, an empty optional is returned.
-		///
-		/// \godbolt{zzG81K}
-		///
-		/// \cpp
-		/// auto tbl = toml::parse(R"(
-		/// 	int	= -10
-		/// 	flt	= 25.0
-		/// 	pi	= 3.14159
-		/// 	bool = false
-		/// 	huge = 9223372036854775807
-		/// 	str	= "foo"
-		/// )"sv);
-		///
-		/// const auto print_value_with_typename =
-		/// 	[&](std::string_view key, std::string_view type_name, auto* dummy)
-		/// 	{
-		/// 		std::cout << "- " << std::setw(18) << std::left << type_name;
-		/// 		using type = std::remove_pointer_t<decltype(dummy)>;
-		/// 		if (auto val = tbl.get(key)->value<type>(); val)
-		/// 			std::cout << *val << "\n";
-		/// 		else
-		/// 			std::cout << "n/a\n";
-		/// 	};
-		///
-		/// #define print_value(key, T) print_value_with_typename(key, #T, (T*)nullptr)
-		///
-		/// for (auto key : { "int", "flt", "pi", "bool", "huge", "str" })
-		/// {
-		/// 	std::cout << tbl[key].type() << " value '" << key << "' as:\n";
-		/// 	print_value(key, bool);
-		/// 	print_value(key, int);
-		/// 	print_value(key, unsigned int);
-		/// 	print_value(key, long long);
-		/// 	print_value(key, float);
-		/// 	print_value(key, double);
-		/// 	print_value(key, std::string);
-		/// 	print_value(key, std::string_view);
-		/// 	print_value(key, const char*);
-		/// 	std::cout << "\n";
-		/// }
-		/// \ecpp
-		///
-		/// \out
-		/// integer value 'int' as:
-		/// - bool              true
-		/// - int               -10
-		/// - unsigned int      n/a
-		/// - long long         -10
-		/// - float             -10
-		/// - double            -10
-		/// - std::string       n/a
-		/// - std::string_view  n/a
-		/// - const char*       n/a
-		///
-		/// floating-point value 'flt' as:
-		/// - bool              n/a
-		/// - int               25
-		/// - unsigned int      25
-		/// - long long         25
-		/// - float             25
-		/// - double            25
-		/// - std::string       n/a
-		/// - std::string_view  n/a
-		/// - const char*       n/a
-		///
-		/// floating-point value 'pi' as:
-		/// - bool              n/a
-		/// - int               n/a
-		/// - unsigned int      n/a
-		/// - long long         n/a
-		/// - float             3.14159
-		/// - double            3.14159
-		/// - std::string       n/a
-		/// - std::string_view  n/a
-		/// - const char*       n/a
-		///
-		/// boolean value 'bool' as:
-		/// - bool              false
-		/// - int               0
-		/// - unsigned int      0
-		/// - long long         0
-		/// - float             n/a
-		/// - double            n/a
-		/// - std::string       n/a
-		/// - std::string_view  n/a
-		/// - const char*       n/a
-		///
-		/// integer value 'huge' as:
-		/// - bool              true
-		/// - int               n/a
-		/// - unsigned int      n/a
-		/// - long long         9223372036854775807
-		/// - float             n/a
-		/// - double            n/a
-		/// - std::string       n/a
-		/// - std::string_view  n/a
-		/// - const char*       n/a
-		///
-		/// string value 'str' as:
-		/// - bool              n/a
-		/// - int               n/a
-		/// - unsigned int      n/a
-		/// - long long         n/a
-		/// - float             n/a
-		/// - double            n/a
-		/// - std::string       foo
-		/// - std::string_view  foo
-		/// - const char*       foo
-		/// \eout
-		///
-		/// \tparam	T	One of the native TOML value types, or a type capable of converting to one.
-		///
-		/// \returns	The underlying value if the node was a value of the matching type (or convertible to it)
-		/// 			and within the range of the output type, or an empty optional.
-		///
-		/// \note		If you want strict value retrieval semantics that do not allow for any type conversions,
-		/// 			use node::value_exact() instead.
-		///
-		/// \see node::value_exact()
-		template <typename T>
-		TOML_NODISCARD
-		optional<T> value() const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		/// \brief	Gets the raw value contained by this node, or a default.
-		///
-		/// \tparam	T				Default value type. Must be one of the native TOML value types,
-		/// 						or convertible to it.
-		/// \param 	default_value	The default value to return if the node wasn't a value, wasn't the
-		/// 						correct type, or no conversion was possible.
-		///
-		/// \returns	The underlying value if the node was a value of the matching type (or convertible to it)
-		/// 			and within the range of the output type, or the provided default.
-		///
-		/// \note	This function has the same permissive retrieval semantics as node::value(). If you want strict
-		/// 		value retrieval semantics that do not allow for any type conversions, use node::value_exact()
-		/// 		instead.
-		///
-		/// \see
-		/// 	- node::value()
-		///		- node::value_exact()
-		template <typename T>
-		TOML_NODISCARD
-		auto value_or(T&& default_value) const noexcept(impl::value_retrieval_is_nothrow<T>);
-
-		/// \brief	Gets a raw reference to a node's underlying data.
-		///
-		/// \warning This function is dangerous if used carelessly and **WILL** break your code if the
-		///			 chosen value type doesn't match the node's actual type. In debug builds an assertion
-		///			 will fire when invalid accesses are attempted: \cpp
-		///
-		/// auto tbl = toml::parse(R"(
-		///		min = 32
-		///		max = 45
-		/// )"sv);
-		///
-		/// int64_t& min_ref = tbl.at("min").ref<int64_t>(); // matching type
-		/// double& max_ref = tbl.at("max").ref<double>();  // mismatched type, hits assert()
-		/// \ecpp
-		///
-		/// \note	Specifying explicit ref qualifiers acts as an explicit ref-category cast,
-		///			whereas specifying explicit cv-ref qualifiers merges them with whatever
-		///			the cv qualification of the node is (to ensure cv-correctness is propagated), e.g.:
-		///			| node        | T                      | return type                  |
-		///			|-------------|------------------------|------------------------------|
-		///			| node&       | std::string            | std::string&                 |
-		///			| node&       | std::string&&          | std::string&&                |
-		///			| const node& | volatile std::string   | const volatile std::string&  |
-		///			| const node& | volatile std::string&& | const volatile std::string&& |
-		///
-		/// \tparam	T	toml::table, toml::array, or one of the TOML value types.
-		///
-		/// \returns	A reference to the underlying data.
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() & noexcept
-		{
-			return do_ref<T>(*this);
-		}
-
-		/// \brief	Gets a raw reference to a node's underlying data (rvalue overload).
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() && noexcept
-		{
-			return do_ref<T>(std::move(*this));
-		}
-
-		/// \brief	Gets a raw reference to a node's underlying data (const lvalue overload).
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() const& noexcept
-		{
-			return do_ref<T>(*this);
-		}
-
-		/// \brief	Gets a raw reference to a node's underlying data (const rvalue overload).
-		template <typename T>
-		TOML_PURE_GETTER
-		decltype(auto) ref() const&& noexcept
-		{
-			return do_ref<T>(std::move(*this));
-		}
-
-		/// @}
-
-		/// \name Metadata
-		/// @{
-
-		/// \brief	Returns the source region responsible for generating this node during parsing.
-		TOML_PURE_INLINE_GETTER
-		const source_region& source() const noexcept
-		{
-			return source_;
-		}
-
-		/// @}
-
-	  private:
-		/// \cond
-
-		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
+TOML_NAMESPACE_START {
+  /// \brief	A TOML node.
+  ///
+  /// \detail A parsed TOML document forms a tree made up of tables, arrays and values.
+  /// 		This type is the base of each of those, providing a lot of the polymorphic plumbing.
+  class TOML_ABSTRACT_INTERFACE TOML_EXPORTED_CLASS node {
+   private:
+    /// \cond
+
+    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));
+    }
+
+    /// \endcond
+
+   public:
+    TOML_EXPORTED_MEMBER_FUNCTION
+    virtual ~node() noexcept;
+
+    /// \name Type checks
+    /// @{
+
+    /// \brief	Checks if a node contains values/elements of only one type.
+    ///
+    /// \detail \cpp
+    /// auto cfg = toml::parse("arr = [ 1, 2, 3, 4.0 ]");
+    /// toml::array& arr = *cfg["arr"].as_array();
+    ///
+    /// toml::node* nonmatch{};
+    /// if (arr.is_homogeneous(toml::node_type::integer, nonmatch))
+    /// 	std::cout << "array was homogeneous"sv << "\n";
+    /// else
+    /// 	std::cout << "array was not homogeneous!\n"
+    /// 	<< "first non-match was a "sv << nonmatch->type() << " at " << nonmatch->source() << "\n";
+    /// \ecpp
+    ///
+    /// \out
+    /// array was not homogeneous!
+    ///	first non-match was a floating-point at line 1, column 18
+    /// \eout
+    ///
+    /// \param	ntype	A TOML node type. <br>
+    /// 				\conditional_return{toml::node_type::none}
+    ///					"is every element the same type?"
+    /// 				\conditional_return{Anything else}
+    ///					"is every element one of these?"
+    ///
+    /// \param first_nonmatch	Reference to a pointer in which the address of the first non-matching
+    /// element 						will be stored if the return value is false.
+    ///
+    /// \returns	True if the node was homogeneous.
+    ///
+    /// \remarks	Always returns `false` for empty tables and arrays.
+    TOML_PURE_GETTER
+    virtual bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept = 0;
+
+    /// \brief	Checks if a node contains values/elements of only one type (const overload).
+    TOML_PURE_GETTER
+    virtual bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept = 0;
+
+    /// \brief	Checks if the node contains values/elements of only one type.
+    ///
+    /// \detail \cpp
+    /// auto arr = toml::array{ 1, 2, 3 };
+    /// std::cout << "homogenous: "sv << arr.is_homogeneous(toml::node_type::none) << "\n";
+    /// std::cout << "all floats: "sv << arr.is_homogeneous(toml::node_type::floating_point) <<
+    /// "\n"; std::cout << "all arrays: "sv << arr.is_homogeneous(toml::node_type::array) << "\n";
+    /// std::cout << "all ints:   "sv << arr.is_homogeneous(toml::node_type::integer) << "\n";
+    /// \ecpp
+    ///
+    /// \out
+    /// homogeneous: true
+    /// all floats:  false
+    /// all arrays:  false
+    /// all ints:    true
+    /// \eout
+    ///
+    /// \param	ntype	A TOML node type. <br>
+    /// 				\conditional_return{toml::node_type::none}
+    ///					"is every element the same type?"
+    /// 				\conditional_return{Anything else}
+    ///					"is every element one of these?"
+    ///
+    /// \returns	True if the node was homogeneous.
+    ///
+    /// \remarks	Always returns `false` for empty tables and arrays.
+    TOML_PURE_GETTER
+    virtual bool is_homogeneous(node_type ntype) const noexcept = 0;
+
+    /// \brief	Checks if the node contains values/elements of only one type.
+    ///
+    /// \detail \cpp
+    /// auto arr = toml::array{ 1, 2, 3 };
+    /// std::cout << "homogenous:   "sv << arr.is_homogeneous() << "\n";
+    /// std::cout << "all doubles:  "sv << arr.is_homogeneous<double>() << "\n";
+    /// std::cout << "all arrays:   "sv << arr.is_homogeneous<toml::array>() << "\n";
+    /// std::cout << "all integers: "sv << arr.is_homogeneous<int64_t>() << "\n";
+    /// \ecpp
+    ///
+    /// \out
+    /// homogeneous: true
+    /// all floats:  false
+    /// all arrays:  false
+    /// all ints:    true
+    /// \eout
+    ///
+    /// \tparam	ElemType	A TOML node or value type. <br>
+    /// 					\conditional_return{Left as `void`}
+    ///						"is every element the same type?" <br>
+    /// 					\conditional_return{Explicitly specified}
+    ///						"is every element a T?"
+    ///
+    /// \returns	True if the node was homogeneous.
+    ///
+    /// \remarks	Always returns `false` for empty tables and arrays.
+    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>);
+    }
+
+    /// \brief	Returns the node's type identifier.
+    TOML_PURE_GETTER
+    virtual node_type type() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a table.
+    TOML_PURE_GETTER
+    virtual bool is_table() const noexcept = 0;
+
+    /// \brief	Returns true if this node is an array.
+    TOML_PURE_GETTER
+    virtual bool is_array() const noexcept = 0;
+
+    /// \brief	Returns true if this node is an array containing only tables.
+    TOML_PURE_GETTER
+    virtual bool is_array_of_tables() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a value.
+    TOML_PURE_GETTER
+    virtual bool is_value() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a string value.
+    TOML_PURE_GETTER
+    virtual bool is_string() const noexcept = 0;
+
+    /// \brief	Returns true if this node is an integer value.
+    TOML_PURE_GETTER
+    virtual bool is_integer() const noexcept = 0;
+
+    /// \brief	Returns true if this node is an floating-point value.
+    TOML_PURE_GETTER
+    virtual bool is_floating_point() const noexcept = 0;
+
+    /// \brief	Returns true if this node is an integer or floating-point value.
+    TOML_PURE_GETTER
+    virtual bool is_number() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a boolean value.
+    TOML_PURE_GETTER
+    virtual bool is_boolean() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a local date value.
+    TOML_PURE_GETTER
+    virtual bool is_date() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a local time value.
+    TOML_PURE_GETTER
+    virtual bool is_time() const noexcept = 0;
+
+    /// \brief	Returns true if this node is a date-time value.
+    TOML_PURE_GETTER
+    virtual bool is_date_time() const noexcept = 0;
+
+    /// \brief	Checks if a node is a specific type.
+    ///
+    /// \tparam	T	A TOML node or value type.
+    ///
+    /// \returns	Returns true if this node is an instance of the specified type.
+    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();
+    }
+
+    /// @}
+
+    /// \name Type casts
+    /// @{
+
+    /// \brief	Returns a pointer to the node as a toml::table, if it is one.
+    TOML_PURE_GETTER
+    virtual table* as_table() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::array, if it is one.
+    TOML_PURE_GETTER
+    virtual array* as_array() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<std::string>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<std::string>* as_string() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<int64_t>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<int64_t>* as_integer() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<double>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<double>* as_floating_point() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<bool>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<bool>* as_boolean() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<toml::date>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<date>* as_date() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<toml::time>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<time>* as_time() noexcept = 0;
+
+    /// \brief	Returns a pointer to the node as a toml::value<toml::date_time>, if it is one.
+    TOML_PURE_GETTER
+    virtual toml::value<date_time>* as_date_time() noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::table, if it is one.
+    TOML_PURE_GETTER
+    virtual const table* as_table() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::array, if it is one.
+    TOML_PURE_GETTER
+    virtual const array* as_array() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<std::string>, if it
+    /// is one.
+    TOML_PURE_GETTER
+    virtual const toml::value<std::string>* as_string() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<int64_t>, if it is
+    /// one.
+    TOML_PURE_GETTER
+    virtual const toml::value<int64_t>* as_integer() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<double>, if it is
+    /// one.
+    TOML_PURE_GETTER
+    virtual const toml::value<double>* as_floating_point() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<bool>, if it is one.
+    TOML_PURE_GETTER
+    virtual const toml::value<bool>* as_boolean() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::date>, if it is
+    /// one.
+    TOML_PURE_GETTER
+    virtual const toml::value<date>* as_date() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::time>, if it is
+    /// one.
+    TOML_PURE_GETTER
+    virtual const toml::value<time>* as_time() const noexcept = 0;
+
+    /// \brief	Returns a const-qualified pointer to the node as a toml::value<toml::date_time>, if
+    /// it is one.
+    TOML_PURE_GETTER
+    virtual const toml::value<date_time>* as_date_time() const noexcept = 0;
+
+    /// \brief	Gets a pointer to the node as a more specific node type.
+    ///
+    /// \details \cpp
+    ///
+    /// toml::value<int64_t>* int_value = node->as<int64_t>();
+    /// toml::table* tbl = node->as<toml::table>();
+    /// if (int_value)
+    ///		std::cout << "Node is a value<int64_t>\n";
+    /// else if (tbl)
+    ///		std::cout << "Node is a table\n";
+    ///
+    ///	// fully-qualified value node types also work (useful for template code):
+    ///	toml::value<int64_t>* int_value2 = node->as<toml::value<int64_t>>();
+    /// if (int_value2)
+    ///		std::cout << "Node is a value<int64_t>\n";
+    /// \ecpp
+    ///
+    /// \tparam	T	The node type or TOML value type to cast to.
+    ///
+    /// \returns	A pointer to the node as the given type, or nullptr if it was a different type.
+    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();
+    }
+
+    /// \brief	Gets a pointer to the node as a more specific node type (const overload).
+    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();
+    }
+
+    /// @}
+
+    /// \name Value retrieval
+    /// @{
+
+    /// \brief	Gets the value contained by this node.
+    ///
+    /// \detail This function has 'exact' retrieval semantics; the only return value types allowed
+    /// are the 		TOML native value types, or types that can losslessly represent a native value type
+    /// (e.g. 		std::wstring on Windows).
+    ///
+    /// \tparam	T	One of the native TOML value types, or a type capable of losslessly representing
+    /// one.
+    ///
+    /// \returns	The underlying value if the node was a value of the
+    /// 			matching type (or losslessly convertible to it), or an empty optional.
+    ///
+    /// \see node::value()
+    template <typename T>
+    TOML_NODISCARD optional<T> value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>);
+
+    /// \brief	Gets the value contained by this node.
+    ///
+    /// \detail This function has 'permissive' retrieval semantics; some value types are allowed
+    /// 		to convert to others (e.g. retrieving a boolean as an integer), and the specified return
+    /// value 		type can be any type where a reasonable conversion from a native TOML value exists
+    /// 		(e.g. std::wstring on Windows). If the source value cannot be represented by
+    /// 		the destination type, an empty optional is returned.
+    ///
+    /// \godbolt{zzG81K}
+    ///
+    /// \cpp
+    /// auto tbl = toml::parse(R"(
+    /// 	int	= -10
+    /// 	flt	= 25.0
+    /// 	pi	= 3.14159
+    /// 	bool = false
+    /// 	huge = 9223372036854775807
+    /// 	str	= "foo"
+    /// )"sv);
+    ///
+    /// const auto print_value_with_typename =
+    /// 	[&](std::string_view key, std::string_view type_name, auto* dummy)
+    /// 	{
+    /// 		std::cout << "- " << std::setw(18) << std::left << type_name;
+    /// 		using type = std::remove_pointer_t<decltype(dummy)>;
+    /// 		if (auto val = tbl.get(key)->value<type>(); val)
+    /// 			std::cout << *val << "\n";
+    /// 		else
+    /// 			std::cout << "n/a\n";
+    /// 	};
+    ///
+    /// #define print_value(key, T) print_value_with_typename(key, #T, (T*)nullptr)
+    ///
+    /// for (auto key : { "int", "flt", "pi", "bool", "huge", "str" })
+    /// {
+    /// 	std::cout << tbl[key].type() << " value '" << key << "' as:\n";
+    /// 	print_value(key, bool);
+    /// 	print_value(key, int);
+    /// 	print_value(key, unsigned int);
+    /// 	print_value(key, long long);
+    /// 	print_value(key, float);
+    /// 	print_value(key, double);
+    /// 	print_value(key, std::string);
+    /// 	print_value(key, std::string_view);
+    /// 	print_value(key, const char*);
+    /// 	std::cout << "\n";
+    /// }
+    /// \ecpp
+    ///
+    /// \out
+    /// integer value 'int' as:
+    /// - bool              true
+    /// - int               -10
+    /// - unsigned int      n/a
+    /// - long long         -10
+    /// - float             -10
+    /// - double            -10
+    /// - std::string       n/a
+    /// - std::string_view  n/a
+    /// - const char*       n/a
+    ///
+    /// floating-point value 'flt' as:
+    /// - bool              n/a
+    /// - int               25
+    /// - unsigned int      25
+    /// - long long         25
+    /// - float             25
+    /// - double            25
+    /// - std::string       n/a
+    /// - std::string_view  n/a
+    /// - const char*       n/a
+    ///
+    /// floating-point value 'pi' as:
+    /// - bool              n/a
+    /// - int               n/a
+    /// - unsigned int      n/a
+    /// - long long         n/a
+    /// - float             3.14159
+    /// - double            3.14159
+    /// - std::string       n/a
+    /// - std::string_view  n/a
+    /// - const char*       n/a
+    ///
+    /// boolean value 'bool' as:
+    /// - bool              false
+    /// - int               0
+    /// - unsigned int      0
+    /// - long long         0
+    /// - float             n/a
+    /// - double            n/a
+    /// - std::string       n/a
+    /// - std::string_view  n/a
+    /// - const char*       n/a
+    ///
+    /// integer value 'huge' as:
+    /// - bool              true
+    /// - int               n/a
+    /// - unsigned int      n/a
+    /// - long long         9223372036854775807
+    /// - float             n/a
+    /// - double            n/a
+    /// - std::string       n/a
+    /// - std::string_view  n/a
+    /// - const char*       n/a
+    ///
+    /// string value 'str' as:
+    /// - bool              n/a
+    /// - int               n/a
+    /// - unsigned int      n/a
+    /// - long long         n/a
+    /// - float             n/a
+    /// - double            n/a
+    /// - std::string       foo
+    /// - std::string_view  foo
+    /// - const char*       foo
+    /// \eout
+    ///
+    /// \tparam	T	One of the native TOML value types, or a type capable of converting to one.
+    ///
+    /// \returns	The underlying value if the node was a value of the matching type (or convertible
+    /// to it) 			and within the range of the output type, or an empty optional.
+    ///
+    /// \note		If you want strict value retrieval semantics that do not allow for any type
+    /// conversions, 			use node::value_exact() instead.
+    ///
+    /// \see node::value_exact()
+    template <typename T>
+    TOML_NODISCARD optional<T> value() const noexcept(impl::value_retrieval_is_nothrow<T>);
+
+    /// \brief	Gets the raw value contained by this node, or a default.
+    ///
+    /// \tparam	T				Default value type. Must be one of the native TOML value types,
+    /// 						or convertible to it.
+    /// \param 	default_value	The default value to return if the node wasn't a value, wasn't the
+    /// 						correct type, or no conversion was possible.
+    ///
+    /// \returns	The underlying value if the node was a value of the matching type (or convertible
+    /// to it) 			and within the range of the output type, or the provided default.
+    ///
+    /// \note	This function has the same permissive retrieval semantics as node::value(). If you
+    /// want strict 		value retrieval semantics that do not allow for any type conversions, use
+    /// node::value_exact() 		instead.
+    ///
+    /// \see
+    /// 	- node::value()
+    ///		- node::value_exact()
+    template <typename T>
+    TOML_NODISCARD auto value_or(T&& default_value) const
+        noexcept(impl::value_retrieval_is_nothrow<T>);
+
+    /// \brief	Gets a raw reference to a node's underlying data.
+    ///
+    /// \warning This function is dangerous if used carelessly and **WILL** break your code if the
+    ///			 chosen value type doesn't match the node's actual type. In debug builds an assertion
+    ///			 will fire when invalid accesses are attempted: \cpp
+    ///
+    /// auto tbl = toml::parse(R"(
+    ///		min = 32
+    ///		max = 45
+    /// )"sv);
+    ///
+    /// int64_t& min_ref = tbl.at("min").ref<int64_t>(); // matching type
+    /// double& max_ref = tbl.at("max").ref<double>();  // mismatched type, hits assert()
+    /// \ecpp
+    ///
+    /// \note	Specifying explicit ref qualifiers acts as an explicit ref-category cast,
+    ///			whereas specifying explicit cv-ref qualifiers merges them with whatever
+    ///			the cv qualification of the node is (to ensure cv-correctness is propagated), e.g.:
+    ///			| node        | T                      | return type                  |
+    ///			|-------------|------------------------|------------------------------|
+    ///			| node&       | std::string            | std::string&                 |
+    ///			| node&       | std::string&&          | std::string&&                |
+    ///			| const node& | volatile std::string   | const volatile std::string&  |
+    ///			| const node& | volatile std::string&& | const volatile std::string&& |
+    ///
+    /// \tparam	T	toml::table, toml::array, or one of the TOML value types.
+    ///
+    /// \returns	A reference to the underlying data.
+    template <typename T>
+    TOML_PURE_GETTER decltype(auto) ref() & noexcept {
+      return do_ref<T>(*this);
+    }
+
+    /// \brief	Gets a raw reference to a node's underlying data (rvalue overload).
+    template <typename T>
+    TOML_PURE_GETTER decltype(auto) ref() && noexcept {
+      return do_ref<T>(std::move(*this));
+    }
+
+    /// \brief	Gets a raw reference to a node's underlying data (const lvalue overload).
+    template <typename T>
+    TOML_PURE_GETTER decltype(auto) ref() const& noexcept {
+      return do_ref<T>(*this);
+    }
+
+    /// \brief	Gets a raw reference to a node's underlying data (const rvalue overload).
+    template <typename T>
+    TOML_PURE_GETTER decltype(auto) ref() const&& noexcept {
+      return do_ref<T>(std::move(*this));
+    }
+
+    /// @}
+
+    /// \name Metadata
+    /// @{
+
+    /// \brief	Returns the source region responsible for generating this node during parsing.
+    TOML_PURE_INLINE_GETTER
+    const source_region& source() const noexcept { return source_; }
+
+    /// @}
+
+   private:
+    /// \cond
+
+    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>		 //
@@ -775,86 +754,87 @@ TOML_NAMESPACE_START
 											  && 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
+    // 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>,
@@ -868,246 +848,244 @@ TOML_NAMESPACE_START
 							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{};
-				}
-			}
-		}
-
-		/// \endcond
-
-	  public:
-		/// \name Visitation
-		/// @{
-
-		/// \brief	Invokes a visitor on the node based on the node's concrete type.
-		///
-		/// \details Visitation is useful when you expect
-		/// 		 a node to be one of a set number of types and need
-		/// 		 to handle these types differently. Using `visit()` allows
-		/// 		 you to eliminate some of the casting/conversion boilerplate: \cpp
-		///
-		/// node.visit([](auto&& n)
-		/// {
-		///		if constexpr (toml::is_string<decltype(n)>)
-		///			do_something_with_a_string(*n)); //n is a toml::value<std::string>
-		///		else if constexpr (toml::is_integer<decltype(n)>)
-		///			do_something_with_an_int(*n); //n is a toml::value<int64_t>
-		/// });
-		/// \ecpp
-		///
-		/// Visitor functions need not be generic; specifying a concrete node type as the input argument type
-		/// effectively acts a 'filter', only invoking the visitor if the concrete type is compatible.
-		/// Thus the example above can be re-written as: \cpp
-		/// node.visit([](toml::value<std::string>& s) { do_something_with_a_string(*s)); });
-		/// node.visit([](toml::value<int64_t>& i)     { do_something_with_an_int(*i)); });
-		/// \ecpp
-		///
-		/// \tparam	Func	A callable type invocable with one or more of the toml++ node types.
-		///
-		/// \param 	visitor	The visitor object.
-		///
-		/// \returns The return value of the visitor.
-		/// 		 Can be void. Non-exhaustive visitors must return a default-constructible type.
-		///
-		/// \see https://en.wikipedia.org/wiki/Visitor_pattern
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) & noexcept(visit_is_nothrow<Func&&, node&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), *this);
-		}
-
-		/// \brief	Invokes a visitor on the node based on the node's concrete type (rvalue overload).
-		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));
-		}
-
-		/// \brief	Invokes a visitor on the node based on the node's concrete type (const lvalue overload).
-		template <typename Func>
-		decltype(auto) visit(Func&& visitor) const& noexcept(visit_is_nothrow<Func&&, const node&>)
-		{
-			return do_visit(static_cast<Func&&>(visitor), *this);
-		}
-
-		/// \brief	Invokes a visitor on the node based on the node's concrete type (const rvalue overload).
-		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));
-		}
-
-		/// @}
-
-		/// \name Node views
-		/// @{
-
-		/// \brief	Creates a node_view pointing to this node.
-		TOML_NODISCARD
-		explicit operator node_view<node>() noexcept;
-
-		/// \brief	Creates a node_view pointing to this node (const overload).
-		TOML_NODISCARD
-		explicit operator node_view<const node>() const noexcept;
-
-		/// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \detail \cpp
-		/// auto config = toml::parse(R"(
-		///
-		/// [foo]
-		/// bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]
-		///
-		/// )"sv);
-		///
-		/// std::cout << config.at_path("foo.bar[2]") << "\n";
-		/// std::cout << config.at_path("foo.bar[3][0]") << "\n";
-		/// std::cout << config.at_path("foo.bar[4].kek") << "\n";
-		/// \ecpp
-		///
-		/// \out
-		/// 2
-		/// 3
-		/// 4
-		/// \eout
-		///
-		///
-		/// \note Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
-		/// \cpp
-		/// config.at_path( "foo.bar")  // same as node_view{ config }["foo"]["bar"]
-		/// config.at_path( "foo. bar") // same as node_view{ config }["foo"][" bar"]
-		/// config.at_path( "foo..bar") // same as node_view{ config }["foo"][""]["bar"]
-		/// config.at_path( ".foo.bar") // same as node_view{ config }[""]["foo"]["bar"]
-		/// \ecpp
-		/// <br>
-		/// Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted strings.
-		/// This function makes no allowance for this, instead treating all period characters as sub-table delimiters.
-		/// If you have periods in your table keys, first consider:
-		/// 1. Not doing that
-		/// 2. Using node_view::operator[] instead.
-		///
-		/// \param path		The "TOML path" to traverse.
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(std::string_view path) noexcept;
-
-		/// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \see #at_path(std::string_view)
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(std::string_view path) const noexcept;
-
-		/// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \detail \cpp
-		/// auto config = toml::parse(R"(
-		///
-		/// [foo]
-		/// bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]
-		///
-		/// )"sv);
-		///
-		/// toml::path path1("foo.bar[2]");
-		/// toml::path path2("foo.bar[4].kek");
-		/// std::cout << config.at_path(path1) << "\n";
-		/// std::cout << config.at_path(path1.parent_path()) << "\n";
-		/// std::cout << config.at_path(path2) << "\n";
-		/// std::cout << config.at_path(path2.parent_path()) << "\n";
-		/// \ecpp
-		///
-		/// \out
-		/// 2
-		/// [ 0, 1, 2, [ 3 ], { kek = 4 } ]
-		/// 4
-		/// { kek  = 4 }
-		/// \eout
-		///
-		///
-		/// \note Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
-		/// \cpp
-		/// config.at_path(toml::path("foo.bar")) // same as node_view{ config }["foo"]["bar"]
-		/// config.at_path(toml::path("foo. bar")) // same as node_view{ config }["foo"][" bar"]
-		/// config.at_path(toml::path("foo..bar")) // same as node_view{ config }["foo"][""]["bar"]
-		/// config.at_path(toml::path(".foo.bar")) // same as node_view{ config }[""]["foo"]["bar"]
-		/// \ecpp
-		/// <br>
-		/// Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted strings.
-		/// This function makes no allowance for this, instead treating all period characters as sub-table delimiters.
-		///
-		/// \param path		The "TOML path" to traverse.
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(const toml::path& path) noexcept;
-
-		/// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \see #at_path(const toml::path&)
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(const toml::path& path) const noexcept;
+        // 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{};
+        }
+      }
+    }
+
+    /// \endcond
+
+   public:
+    /// \name Visitation
+    /// @{
+
+    /// \brief	Invokes a visitor on the node based on the node's concrete type.
+    ///
+    /// \details Visitation is useful when you expect
+    /// 		 a node to be one of a set number of types and need
+    /// 		 to handle these types differently. Using `visit()` allows
+    /// 		 you to eliminate some of the casting/conversion boilerplate: \cpp
+    ///
+    /// node.visit([](auto&& n)
+    /// {
+    ///		if constexpr (toml::is_string<decltype(n)>)
+    ///			do_something_with_a_string(*n)); //n is a toml::value<std::string>
+    ///		else if constexpr (toml::is_integer<decltype(n)>)
+    ///			do_something_with_an_int(*n); //n is a toml::value<int64_t>
+    /// });
+    /// \ecpp
+    ///
+    /// Visitor functions need not be generic; specifying a concrete node type as the input argument
+    /// type effectively acts a 'filter', only invoking the visitor if the concrete type is
+    /// compatible. Thus the example above can be re-written as: \cpp
+    /// node.visit([](toml::value<std::string>& s) { do_something_with_a_string(*s)); });
+    /// node.visit([](toml::value<int64_t>& i)     { do_something_with_an_int(*i)); });
+    /// \ecpp
+    ///
+    /// \tparam	Func	A callable type invocable with one or more of the toml++ node types.
+    ///
+    /// \param 	visitor	The visitor object.
+    ///
+    /// \returns The return value of the visitor.
+    /// 		 Can be void. Non-exhaustive visitors must return a default-constructible type.
+    ///
+    /// \see https://en.wikipedia.org/wiki/Visitor_pattern
+    template <typename Func>
+    decltype(auto) visit(Func&& visitor) & noexcept(visit_is_nothrow<Func&&, node&>) {
+      return do_visit(static_cast<Func&&>(visitor), *this);
+    }
+
+    /// \brief	Invokes a visitor on the node based on the node's concrete type (rvalue overload).
+    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));
+    }
+
+    /// \brief	Invokes a visitor on the node based on the node's concrete type (const lvalue
+    /// overload).
+    template <typename Func>
+    decltype(auto) visit(Func&& visitor) const& noexcept(visit_is_nothrow<Func&&, const node&>) {
+      return do_visit(static_cast<Func&&>(visitor), *this);
+    }
+
+    /// \brief	Invokes a visitor on the node based on the node's concrete type (const rvalue
+    /// overload).
+    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));
+    }
+
+    /// @}
+
+    /// \name Node views
+    /// @{
+
+    /// \brief	Creates a node_view pointing to this node.
+    TOML_NODISCARD
+    explicit operator node_view<node>() noexcept;
+
+    /// \brief	Creates a node_view pointing to this node (const overload).
+    TOML_NODISCARD
+    explicit operator node_view<const node>() const noexcept;
+
+    /// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \detail \cpp
+    /// auto config = toml::parse(R"(
+    ///
+    /// [foo]
+    /// bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]
+    ///
+    /// )"sv);
+    ///
+    /// std::cout << config.at_path("foo.bar[2]") << "\n";
+    /// std::cout << config.at_path("foo.bar[3][0]") << "\n";
+    /// std::cout << config.at_path("foo.bar[4].kek") << "\n";
+    /// \ecpp
+    ///
+    /// \out
+    /// 2
+    /// 3
+    /// 4
+    /// \eout
+    ///
+    ///
+    /// \note Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
+    /// \cpp
+    /// config.at_path( "foo.bar")  // same as node_view{ config }["foo"]["bar"]
+    /// config.at_path( "foo. bar") // same as node_view{ config }["foo"][" bar"]
+    /// config.at_path( "foo..bar") // same as node_view{ config }["foo"][""]["bar"]
+    /// config.at_path( ".foo.bar") // same as node_view{ config }[""]["foo"]["bar"]
+    /// \ecpp
+    /// <br>
+    /// Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted
+    /// strings. This function makes no allowance for this, instead treating all period characters
+    /// as sub-table delimiters. If you have periods in your table keys, first consider:
+    /// 1. Not doing that
+    /// 2. Using node_view::operator[] instead.
+    ///
+    /// \param path		The "TOML path" to traverse.
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<node> at_path(std::string_view path) noexcept;
+
+    /// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \see #at_path(std::string_view)
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<const node> at_path(std::string_view path) const noexcept;
+
+    /// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \detail \cpp
+    /// auto config = toml::parse(R"(
+    ///
+    /// [foo]
+    /// bar = [ 0, 1, 2, [ 3 ], { kek = 4 } ]
+    ///
+    /// )"sv);
+    ///
+    /// toml::path path1("foo.bar[2]");
+    /// toml::path path2("foo.bar[4].kek");
+    /// std::cout << config.at_path(path1) << "\n";
+    /// std::cout << config.at_path(path1.parent_path()) << "\n";
+    /// std::cout << config.at_path(path2) << "\n";
+    /// std::cout << config.at_path(path2.parent_path()) << "\n";
+    /// \ecpp
+    ///
+    /// \out
+    /// 2
+    /// [ 0, 1, 2, [ 3 ], { kek = 4 } ]
+    /// 4
+    /// { kek  = 4 }
+    /// \eout
+    ///
+    ///
+    /// \note Keys in paths are interpreted literally, so whitespace (or lack thereof) matters:
+    /// \cpp
+    /// config.at_path(toml::path("foo.bar")) // same as node_view{ config }["foo"]["bar"]
+    /// config.at_path(toml::path("foo. bar")) // same as node_view{ config }["foo"][" bar"]
+    /// config.at_path(toml::path("foo..bar")) // same as node_view{ config }["foo"][""]["bar"]
+    /// config.at_path(toml::path(".foo.bar")) // same as node_view{ config }[""]["foo"]["bar"]
+    /// \ecpp
+    /// <br>
+    /// Additionally, TOML allows '.' (period) characters to appear in keys if they are quoted
+    /// strings. This function makes no allowance for this, instead treating all period characters
+    /// as sub-table delimiters.
+    ///
+    /// \param path		The "TOML path" to traverse.
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<node> at_path(const toml::path& path) noexcept;
+
+    /// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \see #at_path(const toml::path&)
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<const node> at_path(const toml::path& path) const noexcept;
 
 #if TOML_ENABLE_WINDOWS_COMPAT
 
-		/// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
-		///
-		/// \see #at_path(std::string_view)
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> at_path(std::wstring_view path);
-
-		/// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
-		///
-		/// \see #at_path(std::string_view)
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> at_path(std::wstring_view path) const;
-
-#endif // TOML_ENABLE_WINDOWS_COMPAT
-
-		/// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \param 	path The "TOML path" to the desired child.
-		///
-		/// \returns	A view of the child node at the given path if one existed, or an empty node view.
-		///
-		/// \see toml::node_view
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<node> operator[](const toml::path& path) noexcept;
-
-		/// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
-		///
-		/// \param 	path The "TOML path" to the desired child.
-		///
-		/// \returns	A view of the child node at the given path if one existed, or an empty node view.
-		///
-		/// \see toml::node_view
-		TOML_NODISCARD
-		TOML_EXPORTED_MEMBER_FUNCTION
-		node_view<const node> operator[](const toml::path& path) const noexcept;
-
-		/// @}
-	};
+    /// \brief Returns a view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
+    ///
+    /// \see #at_path(std::string_view)
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<node> at_path(std::wstring_view path);
+
+    /// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \availability This overload is only available when #TOML_ENABLE_WINDOWS_COMPAT is enabled.
+    ///
+    /// \see #at_path(std::string_view)
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<const node> at_path(std::wstring_view path) const;
+
+#endif  // TOML_ENABLE_WINDOWS_COMPAT
+
+    /// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \param 	path The "TOML path" to the desired child.
+    ///
+    /// \returns	A view of the child node at the given path if one existed, or an empty node view.
+    ///
+    /// \see toml::node_view
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<node> operator[](const toml::path& path) noexcept;
+
+    /// \brief Returns a const view of the subnode matching a fully-qualified "TOML path".
+    ///
+    /// \param 	path The "TOML path" to the desired child.
+    ///
+    /// \returns	A view of the child node at the given path if one existed, or an empty node view.
+    ///
+    /// \see toml::node_view
+    TOML_NODISCARD
+    TOML_EXPORTED_MEMBER_FUNCTION
+    node_view<const node> operator[](const toml::path& path) const noexcept;
+
+    /// @}
+  };
 }
 TOML_NAMESPACE_END;
 
 /// \cond
-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_START {
+  TOML_PURE_GETTER
+  TOML_EXPORTED_FREE_FUNCTION
+  bool TOML_CALLCONV node_deep_equality(const node*, const node*) noexcept;
 }
 TOML_IMPL_NAMESPACE_END;
 /// \endcond