toml.hpp

Go to the documentation of this file.

//----------------------------------------------------------------------------------------------------------------------
//
// toml++ v3.4.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_HPP
#define TOMLPLUSPLUS_HPP
 
#define INCLUDE_TOMLPLUSPLUS_H // old guard name used pre-v3
#define TOMLPLUSPLUS_H         // guard name used in the legacy toml.h
 
//********  impl/preprocessor.hpp  *************************************************************************************
 
#ifndef __cplusplus
#error toml++ is a C++ library.
#endif
 
#ifndef TOML_CPP
#ifdef _MSVC_LANG
#if _MSVC_LANG > __cplusplus
#define TOML_CPP _MSVC_LANG
#endif
#endif
#ifndef TOML_CPP
#define TOML_CPP __cplusplus
#endif
#if TOML_CPP >= 202900L
#undef TOML_CPP
#define TOML_CPP 29
#elif TOML_CPP >= 202600L
#undef TOML_CPP
#define TOML_CPP 26
#elif TOML_CPP >= 202302L
#undef TOML_CPP
#define TOML_CPP 23
#elif TOML_CPP >= 202002L
#undef TOML_CPP
#define TOML_CPP 20
#elif TOML_CPP >= 201703L
#undef TOML_CPP
#define TOML_CPP 17
#elif TOML_CPP >= 201402L
#undef TOML_CPP
#define TOML_CPP 14
#elif TOML_CPP >= 201103L
#undef TOML_CPP
#define TOML_CPP 11
#else
#undef TOML_CPP
#define TOML_CPP 0
#endif
#endif
 
#if !TOML_CPP
#error toml++ requires C++17 or higher. For a pre-C++11 TOML library see https://github.com/ToruNiina/Boost.toml
#elif TOML_CPP < 17
#error toml++ requires C++17 or higher. For a C++11 TOML library see https://github.com/ToruNiina/toml11
#endif
 
#ifndef TOML_MAKE_VERSION
#define TOML_MAKE_VERSION(major, minor, patch) (((major)*10000) + ((minor)*100) + ((patch)))
#endif
 
#ifndef TOML_INTELLISENSE
#ifdef __INTELLISENSE__
#define TOML_INTELLISENSE 1
#else
#define TOML_INTELLISENSE 0
#endif
#endif
 
#ifndef TOML_DOXYGEN
#if defined(DOXYGEN) || defined(__DOXYGEN) || defined(__DOXYGEN__) || defined(__doxygen__) || defined(__POXY__)        \
    || defined(__poxy__)
#define TOML_DOXYGEN 1
#else
#define TOML_DOXYGEN 0
#endif
#endif
 
#ifndef TOML_CLANG
#ifdef __clang__
#define TOML_CLANG __clang_major__
#else
#define TOML_CLANG 0
#endif
 
// special handling for apple clang; see:
// - https://github.com/marzer/tomlplusplus/issues/189
// - https://en.wikipedia.org/wiki/Xcode
// -
// https://stackoverflow.com/questions/19387043/how-can-i-reliably-detect-the-version-of-clang-at-preprocessing-time
#if TOML_CLANG && defined(__apple_build_version__)
#undef TOML_CLANG
#define TOML_CLANG_VERSION TOML_MAKE_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
#if TOML_CLANG_VERSION >= TOML_MAKE_VERSION(15, 0, 0)
#define TOML_CLANG 16
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(14, 3, 0)
#define TOML_CLANG 15
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(14, 0, 0)
#define TOML_CLANG 14
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(13, 1, 6)
#define TOML_CLANG 13
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(13, 0, 0)
#define TOML_CLANG 12
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(12, 0, 5)
#define TOML_CLANG 11
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(12, 0, 0)
#define TOML_CLANG 10
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(11, 0, 3)
#define TOML_CLANG 9
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(11, 0, 0)
#define TOML_CLANG 8
#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(10, 0, 1)
#define TOML_CLANG 7
#else
#define TOML_CLANG 6 // not strictly correct but doesn't matter below this
#endif
#undef TOML_CLANG_VERSION
#endif
#endif
 
#ifndef TOML_ICC
#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
#endif
 
#ifndef TOML_MSVC_LIKE
#ifdef _MSC_VER
#define TOML_MSVC_LIKE _MSC_VER
#else
#define TOML_MSVC_LIKE 0
#endif
#endif
 
#ifndef TOML_MSVC
#if TOML_MSVC_LIKE && !TOML_CLANG && !TOML_ICC
#define TOML_MSVC TOML_MSVC_LIKE
#else
#define TOML_MSVC 0
#endif
#endif
 
#ifndef TOML_GCC_LIKE
#ifdef __GNUC__
#define TOML_GCC_LIKE __GNUC__
#else
#define TOML_GCC_LIKE 0
#endif
#endif
 
#ifndef TOML_GCC
#if TOML_GCC_LIKE && !TOML_CLANG && !TOML_ICC
#define TOML_GCC TOML_GCC_LIKE
#else
#define TOML_GCC 0
#endif
#endif
 
#ifndef TOML_CUDA
#if defined(__CUDACC__) || defined(__CUDA_ARCH__) || defined(__CUDA_LIBDEVICE__)
#define TOML_CUDA 1
#else
#define TOML_CUDA 0
#endif
#endif
 
#ifndef TOML_ARCH_ITANIUM
#if defined(__ia64__) || defined(__ia64) || defined(_IA64) || defined(__IA64__) || defined(_M_IA64)
#define TOML_ARCH_ITANIUM 1
#define TOML_ARCH_BITNESS 64
#else
#define TOML_ARCH_ITANIUM 0
#endif
#endif
 
#ifndef TOML_ARCH_AMD64
#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
#define TOML_ARCH_AMD64   1
#define TOML_ARCH_BITNESS 64
#else
#define TOML_ARCH_AMD64 0
#endif
#endif
 
#ifndef TOML_ARCH_X86
#if defined(__i386__) || defined(_M_IX86)
#define TOML_ARCH_X86     1
#define TOML_ARCH_BITNESS 32
#else
#define TOML_ARCH_X86 0
#endif
#endif
 
#ifndef TOML_ARCH_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
#define TOML_ARCH_BITNESS 64
#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
#define TOML_ARCH_BITNESS 32
#else
#define TOML_ARCH_ARM32 0
#define TOML_ARCH_ARM64 0
#define TOML_ARCH_ARM   0
#endif
#endif
 
#ifndef TOML_ARCH_BITNESS
#define TOML_ARCH_BITNESS 0
#endif
 
#ifndef TOML_ARCH_X64
#if TOML_ARCH_BITNESS == 64
#define TOML_ARCH_X64 1
#else
#define TOML_ARCH_X64 0
#endif
#endif
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__CYGWIN__)
#define TOML_WINDOWS 1
#else
#define TOML_WINDOWS 0
#endif
 
#ifdef __unix__
#define TOML_UNIX 1
#else
#define TOML_UNIX 0
#endif
 
#ifdef __linux__
#define TOML_LINUX 1
#else
#define TOML_LINUX 0
#endif
 
// TOML_HAS_INCLUDE
#ifndef TOML_HAS_INCLUDE
#ifdef __has_include
#define TOML_HAS_INCLUDE(header)        __has_include(header)
#else
#define TOML_HAS_INCLUDE(header) 0
#endif
#endif
 
// TOML_HAS_BUILTIN
#ifndef TOML_HAS_BUILTIN
#ifdef __has_builtin
#define TOML_HAS_BUILTIN(name) __has_builtin(name)
#else
#define TOML_HAS_BUILTIN(name) 0
#endif
#endif
 
// TOML_HAS_FEATURE
#ifndef TOML_HAS_FEATURE
#ifdef __has_feature
#define TOML_HAS_FEATURE(name) __has_feature(name)
#else
#define TOML_HAS_FEATURE(name) 0
#endif
#endif
 
// TOML_HAS_ATTR
#ifndef TOML_HAS_ATTR
#ifdef __has_attribute
#define TOML_HAS_ATTR(attr) __has_attribute(attr)
#else
#define TOML_HAS_ATTR(attr) 0
#endif
#endif
 
// TOML_HAS_CPP_ATTR
#ifndef 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
#endif
 
// TOML_ATTR (gnu attributes)
#ifndef TOML_ATTR
#if TOML_CLANG || TOML_GCC_LIKE
#define TOML_ATTR(...) __attribute__((__VA_ARGS__))
#else
#define TOML_ATTR(...)
#endif
#endif
 
// TOML_DECLSPEC (msvc attributes)
#ifndef TOML_DECLSPEC
#if TOML_MSVC_LIKE
#define TOML_DECLSPEC(...) __declspec(__VA_ARGS__)
#else
#define TOML_DECLSPEC(...)
#endif
#endif
 
// TOML_COMPILER_HAS_EXCEPTIONS
#ifndef 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
#endif
 
// TOML_COMPILER_HAS_RTTI
#ifndef 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
#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 >= 8
#define TOML_PRAGMA_CLANG_GE_8(decl) TOML_PRAGMA_CLANG(decl)
#else
#define TOML_PRAGMA_CLANG_GE_8(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_CUDA // https://gitlab.gnome.org/GNOME/glib/-/issues/2555
#define TOML_NEVER_INLINE TOML_ATTR(noinline)
#else
#if TOML_GCC || TOML_CLANG || TOML_HAS_ATTR(__noinline__)
#define TOML_NEVER_INLINE TOML_ATTR(__noinline__)
#endif
#endif
#ifndef TOML_NEVER_INLINE
#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
#ifndef TOML_PURE
#ifdef NDEBUG
#define TOML_PURE                                                                                                      \
    TOML_DECLSPEC(noalias)                                                                                             \
    TOML_ATTR(pure)
#else
#define TOML_PURE
#endif
#endif
#ifndef TOML_CONST
#ifdef NDEBUG
#define TOML_CONST                                                                                                     \
    TOML_DECLSPEC(noalias)                                                                                             \
    TOML_ATTR(const)
#else
#define TOML_CONST
#endif
#endif
#ifndef TOML_INLINE_GETTER
#define TOML_INLINE_GETTER                                                                                             \
    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE
#endif
#ifndef TOML_PURE_GETTER
#define TOML_PURE_GETTER                                                                                               \
    TOML_NODISCARD                                                                                                     \
    TOML_PURE
#endif
#ifndef TOML_PURE_INLINE_GETTER
#define TOML_PURE_INLINE_GETTER                                                                                        \
    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE                                                                                                 \
    TOML_PURE
#endif
#ifndef TOML_CONST_GETTER
#define TOML_CONST_GETTER                                                                                              \
    TOML_NODISCARD                                                                                                     \
    TOML_CONST
#endif
#ifndef TOML_CONST_INLINE_GETTER
#define TOML_CONST_INLINE_GETTER                                                                                       \
    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE                                                                                                 \
    TOML_CONST
#endif
 
// TOML_ASSUME
#ifdef _MSC_VER
#define TOML_ASSUME(expr) __assume(expr)
#elif TOML_ICC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_assume)
#define TOML_ASSUME(expr) __builtin_assume(expr)
#elif TOML_HAS_CPP_ATTR(assume) >= 202207
#define TOML_ASSUME(expr) [[assume(expr)]]
#elif TOML_HAS_ATTR(__assume__)
#define TOML_ASSUME(expr) __attribute__((__assume__(expr)))
#else
#define TOML_ASSUME(expr) static_cast<void>(0)
#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_cast<void>(0)
#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)                                                                                 \
    TOML_PRAGMA_CLANG(diagnostic ignored "-Wunknown-warning-option")                                                   \
    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_GE_10(diagnostic ignored "-Wimplicit-int-float-conversion")                                      \
    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_8(diagnostic ignored "-Wdefaulted-function-deleted")                                          \
    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
 
#ifndef TOML_ENABLE_FLOAT16
#define TOML_ENABLE_FLOAT16 0
#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__)
 
#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.hpp  ******************************************************************************************
 
#define TOML_LIB_MAJOR 3
#define TOML_LIB_MINOR 4
#define TOML_LIB_PATCH 0
 
#define TOML_LANG_MAJOR 1
#define TOML_LANG_MINOR 0
#define TOML_LANG_PATCH 0
 
//********  impl/preprocessor.hpp  *************************************************************************************
 
#define TOML_LIB_SINGLE_HEADER 1
 
#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
TOML_PRAGMA_CLANG(diagnostic ignored "-Wheader-hygiene")
#if TOML_CLANG >= 12
TOML_PRAGMA_CLANG(diagnostic ignored "-Wc++20-extensions")
#endif
#if TOML_CLANG == 13
TOML_PRAGMA_CLANG(diagnostic ignored "-Wreserved-identifier")
#endif
#endif
 
//********  impl/std_new.hpp  ******************************************************************************************
 
TOML_DISABLE_WARNINGS;
#include <new>
TOML_ENABLE_WARNINGS;
 
#if (!defined(__apple_build_version__) && 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.hpp  ***************************************************************************************
 
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.hpp  *************************************************************************************
 
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.hpp  *****************************************************************************
 
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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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);
#ifdef FLT_RADIX
static_assert(FLT_RADIX == 2, TOML_ENV_MESSAGE);
#endif
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);
static_assert(std::numeric_limits<double>::radix == 2, 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...>
    inline constexpr bool always_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;
 
    template <typename T, bool = std::is_enum_v<T>>
    struct underlying_type_
    {
        using type = std::underlying_type_t<T>;
    };
    template <typename T>
    struct underlying_type_<T, false>
    {
        using type = T;
    };
    template <typename T>
    using underlying_type = typename underlying_type_<T>::type;
 
    // general value traits
    // (as they relate to their equivalent native TOML type)
    struct default_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;
 
    template <typename T, bool = std::is_enum_v<T>>
    struct value_traits_base_selector
    {
        static_assert(!is_cvref<T>);
 
        using type = default_value_traits;
    };
    template <typename T>
    struct value_traits_base_selector<T, true>
    {
        static_assert(!is_cvref<T>);
 
        using type = value_traits<underlying_type<T>>;
    };
 
    template <typename T>
    struct value_traits : value_traits_base_selector<T>::type
    {};
    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 T min = T{ (std::numeric_limits<underlying_type<T>>::min)() };
        static constexpr T max = T{ (std::numeric_limits<underlying_type<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<underlying_type<T>, native_type>;
        static constexpr bool is_signed = static_cast<underlying_type<T>>(-1) < underlying_type<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<underlying_type<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<underlying_type<T>>::min >= (-9223372036854775807LL - 1LL)
            && integer_limits<underlying_type<T>>::max <= 9223372036854775807LL;
        static constexpr bool can_represent_native =
            integer_limits<underlying_type<T>>::min <= (-9223372036854775807LL - 1LL)
            && integer_limits<underlying_type<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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/print_to_stream.hpp  **********************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/source_region.hpp  ************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/date_time.hpp  ****************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/at_path.hpp  ******************************************************************************************
 
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.hpp  ***************************************************************************************
 
TOML_DISABLE_WARNINGS;
#include <vector>
#include <iterator>
TOML_ENABLE_WARNINGS;
 
//********  impl/path.hpp  *********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/std_utility.hpp  **************************************************************************************
 
TOML_DISABLE_WARNINGS;
#include <utility>
TOML_ENABLE_WARNINGS;
 
//********  impl/node.hpp  *********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/std_initializer_list.hpp  *****************************************************************************
 
TOML_DISABLE_WARNINGS;
#include <initializer_list>
TOML_ENABLE_WARNINGS;
 
//********  impl/node_view.hpp  ****************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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::always_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::always_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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/value.hpp  ********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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 integral 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)
        {
            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) };
    }
 
    template <typename...>
    struct value_variadic_ctor_allowed : std::true_type
    {};
 
    template <typename T, typename... Args>
    struct value_variadic_ctor_allowed<value<T>, value<T>, Args...> : std::false_type
    {};
}
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&>>);
 
        TOML_HIDDEN_CONSTRAINT(
            (impl::value_variadic_ctor_allowed<value<ValueType>, impl::remove_cvref<Args>...>::value),
            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_{ std::exchange(other.flags_, value_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
            other.flags_ = {};
        }
 
        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_ = std::exchange(rhs.flags_, value_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>
    value(T, value_flags) -> 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(always_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(always_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(always_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 integral 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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/make_node.hpp  ****************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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), flags };
            }
 
            // 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(always_false<T>,
                                      "Integral value initializers must be losslessly convertible to int64_t");
                    else if constexpr (std::is_same_v<native_type, double>)
                        static_assert(always_false<T>,
                                      "Floating-point value initializers must be losslessly convertible to double");
                    else
                        static_assert(
                            always_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(always_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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/array.hpp  ********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#pragma push_macro("min")
#pragma push_macro("max")
#undef min
#undef max
#endif
 
#ifndef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN
#if TOML_GCC && TOML_GCC <= 7
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 1
#else
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 0
#endif
#endif
 
#if TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN && !defined(TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED)
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE                                                                  \
    "If you're seeing this error it's because you're using one of toml++'s for_each() functions on a compiler with "   \
    "known bugs in that area (e.g. GCC 7). On these compilers returning a bool (or bool-convertible) value from the "  \
    "for_each() callable causes spurious compilation failures, while returning nothing (void) works fine. "            \
    "If you believe this message is incorrect for your compiler, you can try your luck by #defining "                  \
    "TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN as 0 and recompiling - if it works, great! Let me know at "                 \
    "https://github.com/marzer/tomlplusplus/issues. Alternatively, if you don't have any need for early-exiting from " \
    "for_each(), you can suppress this error by #defining TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED "         \
    "and moving on with your life."
#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>
        using can_for_each = std::disjunction<std::is_invocable<Func, for_each_elem_ref<T, Array>, size_t>,
                                              std::is_invocable<Func, size_t, for_each_elem_ref<T, Array>>,
                                              std::is_invocable<Func, for_each_elem_ref<T, Array>>>;
 
        template <typename Func, typename Array, typename T>
        using can_for_each_nothrow = std::conditional_t<
            // first form
            std::is_invocable_v<Func, for_each_elem_ref<T, Array>, size_t>,
            std::is_nothrow_invocable<Func, for_each_elem_ref<T, Array>, size_t>,
            std::conditional_t<
                // second form
                std::is_invocable_v<Func, size_t, for_each_elem_ref<T, Array>>,
                std::is_nothrow_invocable<Func, size_t, for_each_elem_ref<T, Array>>,
                std::conditional_t<
                    // third form
                    std::is_invocable_v<Func, for_each_elem_ref<T, Array>>,
                    std::is_nothrow_invocable<Func, for_each_elem_ref<T, Array>>,
                    std::false_type>>>;
 
        template <typename Func, typename Array>
        using can_for_each_any = std::disjunction<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>
        using for_each_is_nothrow_one = std::disjunction<std::negation<can_for_each<Func, Array, T>>, //
                                                         can_for_each_nothrow<Func, Array, T>>;
 
        template <typename Func, typename Array>
        using for_each_is_nothrow = std::conjunction<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>>;
 
        template <typename Func, typename Array>
        static void do_for_each(Func&& visitor, Array&& arr) //
            noexcept(for_each_is_nothrow<Func&&, Array&&>::value)
        {
            static_assert(can_for_each_any<Func&&, Array&&>::value,
                          "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>);
 
#if TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN
 
#ifndef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED
                static_assert(impl::always_false<Func, Array, node_ref>, //
                              TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE);
#endif
 
                static_cast<node_ref>(static_cast<Array&&>(arr)[i])
                    .visit(
                        [&]([[maybe_unused]] auto&& elem) //
                        noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>::value)
                        {
                            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>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
                            }
 
                            // func(i, elem)
                            else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
                            {
                                static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
                            }
 
                            // func(elem)
                            else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
                            }
                        });
 
#else
                const auto keep_going =
                    static_cast<node_ref>(static_cast<Array&&>(arr)[i])
                        .visit(
                            [&]([[maybe_unused]] auto&& elem) //
                            noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>::value)
                            {
                                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;
#endif
            }
        }
 
      public:
 
        template <typename Func>
        array& for_each(Func&& visitor) & //
            noexcept(for_each_is_nothrow<Func&&, array&>::value)
        {
            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&&>::value)
        {
            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&>::value)
        {
            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&&>::value)
        {
            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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/key.hpp  **********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/std_map.hpp  ******************************************************************************************
 
TOML_DISABLE_WARNINGS;
#include <map>
#include <iterator>
TOML_ENABLE_WARNINGS;
 
//********  impl/table.hpp  ********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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>
        using can_for_each = std::disjunction<std::is_invocable<Func, const key&, for_each_value_ref<T, Table>>, //
                                              std::is_invocable<Func, for_each_value_ref<T, Table>>>;
 
        template <typename Func, typename Table, typename T>
        using can_for_each_nothrow = std::conditional_t<
            // first form
            std::is_invocable_v<Func, const key&, for_each_value_ref<T, Table>>,
            std::is_nothrow_invocable<Func, const key&, for_each_value_ref<T, Table>>,
            std::conditional_t<
                // second form
                std::is_invocable_v<Func, for_each_value_ref<T, Table>>,
                std::is_nothrow_invocable<Func, for_each_value_ref<T, Table>>,
                std::false_type>>;
 
        template <typename Func, typename Table>
        using can_for_each_any = std::disjunction<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>
        using for_each_is_nothrow_one = std::disjunction<std::negation<can_for_each<Func, Table, T>>, //
                                                         can_for_each_nothrow<Func, Table, T>>;
 
        template <typename Func, typename Table>
        using for_each_is_nothrow = std::conjunction<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>>;
 
        template <typename Func, typename Table>
        static void do_for_each(Func&& visitor, Table&& tbl) //
            noexcept(for_each_is_nothrow<Func&&, Table&&>::value)
        {
            static_assert(can_for_each_any<Func&&, Table&&>::value,
                          "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>);
 
#if TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN
 
#ifndef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED
                static_assert(impl::always_false<Func, Table, kvp_type, node_ref>, //
                              TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE);
#endif
 
                static_cast<node_ref>(*kvp.second)
                    .visit(
                        [&]([[maybe_unused]] auto&& v) //
                        noexcept(for_each_is_nothrow_one<Func&&, Table&&, decltype(v)>::value)
                        {
                            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>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<const key&>(kvp.first),
                                                             static_cast<value_ref>(v));
                            }
 
                            // func(val)
                            else if constexpr (std::is_invocable_v<Func&&, value_ref>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<value_ref>(v));
                            }
                        });
 
#else
                const auto keep_going =
                    static_cast<node_ref>(*kvp.second)
                        .visit(
                            [&]([[maybe_unused]] auto&& v) //
                            noexcept(for_each_is_nothrow_one<Func&&, Table&&, decltype(v)>::value)
                            {
                                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;
#endif
            }
        }
 
      public:
 
        template <typename Func>
        table& for_each(Func&& visitor) & //
            noexcept(for_each_is_nothrow<Func&&, table&>::value)
        {
            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&&>::value)
        {
            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&>::value)
        {
            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&&>::value)
        {
            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::always_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::always_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::always_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::always_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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/unicode_autogenerated.hpp  ****************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/unicode.hpp  ******************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/parse_error.hpp  **************************************************************************************
 
#if TOML_ENABLE_PARSER
 
//********  impl/std_except.hpp  ***************************************************************************************
 
TOML_DISABLE_WARNINGS;
#if TOML_EXCEPTIONS
#include <stdexcept>
#endif
TOML_ENABLE_WARNINGS;
 
//********  impl/parse_error.hpp  **************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_PARSER
 
//********  impl/parse_result.hpp  *************************************************************************************
 
#if TOML_DOXYGEN || (TOML_ENABLE_PARSER && !TOML_EXCEPTIONS)
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_PARSER && !TOML_EXCEPTIONS
 
//********  impl/parser.hpp  *******************************************************************************************
 
#if TOML_ENABLE_PARSER
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_PARSER
 
//********  impl/formatter.hpp  ****************************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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,
                          bool allow_literal_whitespace = true);
 
        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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/toml_formatter.hpp  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/json_formatter.hpp  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/yaml_formatter.hpp  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/node.inl  *********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/array.inl  ********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/table.inl  ********************************************************************************************
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
//********  impl/simd.hpp  *********************************************************************************************
 
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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::always_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
                static constexpr auto i64_max = static_cast<uint64_t>((std::numeric_limits<int64_t>::max)());
                if TOML_UNLIKELY(result > i64_max + (sign < 0 ? 1u : 0u))
                    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)
                {
                    // avoid signed multiply UB when parsing INT64_MIN
                    if TOML_UNLIKELY(sign < 0 && result == i64_max + 1u)
                        return (std::numeric_limits<int64_t>::min)();
 
                    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)
                    {
                        bool ok = true;
                        if (!tbl->empty())
                        {
                            for (auto& [_, child] : *tbl)
                            {
                                if (!child.is_table() && !child.is_array_of_tables())
                                {
                                    ok = false;
                                    break;
                                }
                            }
                        }
 
                        if (ok)
                        {
                            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).c_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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_PARSER
 
//********  impl/formatter.inl  ****************************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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,
                                 bool allow_literal_whitespace)
    {
        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();
        }
 
        // strings with line breaks, tabs, and single-quotes can't be bare
        if (!!(traits
               & (formatted_string_traits::line_breaks | formatted_string_traits::tabs
                  | formatted_string_traits::single_quotes)))
            traits |= formatted_string_traits::non_bare;
 
        // 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;
        }
        const auto real_tabs_allowed = allow_literal_whitespace && real_tabs_in_strings_allowed();
 
        // determine if this should be a multi-line string (triple-quotes)
        const auto multi_line = allow_literal_whitespace     //
                             && 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_allowed)   //
                          && (!(traits & formatted_string_traits::line_breaks) || multi_line)   //
                          && (!(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);
 
        // 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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/toml_formatter.inl  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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, false);
    }
 
    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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/json_formatter.inl  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#endif
TOML_POP_WARNINGS;
 
#endif // TOML_ENABLE_FORMATTERS
 
//********  impl/yaml_formatter.inl  ***********************************************************************************
 
#if TOML_ENABLE_FORMATTERS
 
TOML_PUSH_WARNINGS;
#ifdef _MSC_VER
#ifndef __clang__
#pragma inline_recursion(on)
#endif
#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")
#ifndef __clang__
#pragma inline_recursion(off)
#endif
#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_BITNESS
#undef TOML_ARCH_ITANIUM
#undef TOML_ARCH_X64
#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_CLANG_VERSION
#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_GCC_LIKE
#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_INLINE_GETTER
#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_LINUX
#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_MSVC_LIKE
#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_8
#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_RETURN_BOOL_FROM_FOR_EACH_BROKEN
#undef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE
#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_UNIX
#undef TOML_UNLIKELY
#undef TOML_UNLIKELY_CASE
#undef TOML_UNREACHABLE
#undef TOML_UNUSED
#undef TOML_WINDOWS
#endif
 
#endif // TOMLPLUSPLUS_HPP