dilemmaker/source/fkYAML/node.hpp

//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_NODE_HPP
#define FK_YAML_NODE_HPP

#include <algorithm>
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

// #include <fkYAML/detail/macros/define_macros.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_MACROS_DEFINE_MACROS_HPP
#define FK_YAML_DETAIL_MACROS_DEFINE_MACROS_HPP

// #include <fkYAML/detail/macros/version_macros.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

// Check version definitions if already defined.
#if defined(FK_YAML_MAJOR_VERSION) && defined(FK_YAML_MINOR_VERSION) && defined(FK_YAML_PATCH_VERSION)
#if FK_YAML_MAJOR_VERSION != 0 || FK_YAML_MINOR_VERSION != 4 || FK_YAML_PATCH_VERSION != 2
#warning Already included a different version of the fkYAML library!
#else
// define macros to skip defining macros down below.
#define FK_YAML_VERCHECK_SUCCEEDED
#endif
#endif

#ifndef FK_YAML_VERCHECK_SUCCEEDED

#define FK_YAML_MAJOR_VERSION 0
#define FK_YAML_MINOR_VERSION 4
#define FK_YAML_PATCH_VERSION 2

#define FK_YAML_NAMESPACE_VERSION_CONCAT_IMPL(major, minor, patch) v##major##_##minor##_##patch

#define FK_YAML_NAMESPACE_VERSION_CONCAT(major, minor, patch) FK_YAML_NAMESPACE_VERSION_CONCAT_IMPL(major, minor, patch)

#define FK_YAML_NAMESPACE_VERSION                                                                                      \
    FK_YAML_NAMESPACE_VERSION_CONCAT(FK_YAML_MAJOR_VERSION, FK_YAML_MINOR_VERSION, FK_YAML_PATCH_VERSION)

#define FK_YAML_NAMESPACE_BEGIN                                                                                        \
    namespace fkyaml {                                                                                                 \
    inline namespace FK_YAML_NAMESPACE_VERSION {

#define FK_YAML_NAMESPACE_END                                                                                          \
    } /* inline namespace FK_YAML_NAMESPACE_VERSION */                                                                 \
    } // namespace fkyaml

#define FK_YAML_DETAIL_NAMESPACE_BEGIN                                                                                 \
    FK_YAML_NAMESPACE_BEGIN                                                                                            \
    namespace detail {

#define FK_YAML_DETAIL_NAMESPACE_END                                                                                   \
    } /* namespace detail */                                                                                           \
    FK_YAML_NAMESPACE_END

#endif // !defined(FK_YAML_VERCHECK_SUCCEEDED)

// #include <fkYAML/detail/macros/cpp_config_macros.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_MACROS_CPP_CONFIG_MACROS_HPP
#define FK_YAML_DETAIL_MACROS_CPP_CONFIG_MACROS_HPP

// This file is assumed to be included only by version_macros.hpp file.
// To avoid redundant inclusion, do not include version_macros.hpp file as the other files do.

// With the MSVC compilers, the value of __cplusplus is by default always "199611L"(C++98).
// To avoid that, the library instead references _MSVC_LANG which is always set a correct value.
// See https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/ for more details.
#if defined(_MSVC_LANG) && !defined(__clang__)
#define FK_YAML_CPLUSPLUS _MSVC_LANG
#else
#define FK_YAML_CPLUSPLUS __cplusplus
#endif

// C++ language standard detection
// Skip detection if the definitions listed below already exist.
#if !defined(FK_YAML_HAS_CXX_23) && !defined(FK_YAML_HAS_CXX_20) && !defined(FK_YAML_HAS_CXX_17) &&                    \
    !defined(FK_YAML_HAS_CXX_14) && !defined(FK_YAML_CXX_11)
#if FK_YAML_CPLUSPLUS >= 202302L
#define FK_YAML_HAS_CXX_23
#define FK_YAML_HAS_CXX_20
#define FK_YAML_HAS_CXX_17
#define FK_YAML_HAS_CXX_14
#elif FK_YAML_CPLUSPLUS >= 202002L
#define FK_YAML_HAS_CXX_20
#define FK_YAML_HAS_CXX_17
#define FK_YAML_HAS_CXX_14
#elif FK_YAML_CPLUSPLUS >= 201703L
#define FK_YAML_HAS_CXX_17
#define FK_YAML_HAS_CXX_14
#elif FK_YAML_CPLUSPLUS >= 201402L
#define FK_YAML_HAS_CXX_14
#endif

// C++11 is the minimum required version of the fkYAML library.
#define FK_YAML_HAS_CXX_11
#endif

// switch usage of the deprecated attribute. [[deprecated]] is available since C++14.
#if defined(FK_YAML_HAS_CXX_14)
#define FK_YAML_DEPRECATED(msg) [[deprecated(msg)]]
#else
#if defined(_MSC_VER)
#define FK_YAML_DEPRECATED(msg) __declspec(deprecated(msg))
#elif defined(__GNUC__) || defined(__clang__)
#define FK_YAML_DEPRECATED(msg) __attribute__((deprecated(msg)))
#else
#define FK_YAML_DEPRECATED(msg)
#endif
#endif

// switch usage of inline variables which have been available since C++17.
#if defined(FK_YAML_HAS_CXX_17)
#define FK_YAML_INLINE_VAR inline
#else
#define FK_YAML_INLINE_VAR
#endif

// switch usage of constexpr keyword depending on active C++ standard.
#if defined(FK_YAML_HAS_CXX_17)
#define FK_YAML_CXX17_CONSTEXPR constexpr
#else
#define FK_YAML_CXX17_CONSTEXPR
#endif

// Detect __has_* macros.
// The following macros replace redundant `defined(__has_*) && __has_*(...)`.

#ifdef __has_include
#define FK_YAML_HAS_INCLUDE(header) __has_include(header)
#else
#define FK_YAML_HAS_INCLUDE(header) (0)
#endif

#ifdef __has_builtin
#define FK_YAML_HAS_BUILTIN(builtin) __has_builtin(builtin)
#else
#define FK_YAML_HAS_BUILTIN(builtin) (0)
#endif

#ifdef __has_cpp_attribute
#define FK_YAML_HAS_CPP_ATTRIBUTE(attr) __has_cpp_attribute(attr)
#else
#define FK_YAML_HAS_CPP_ATTRIBUTE(attr) (0)
#endif

#ifdef __has_feature
#define FK_YAML_HAS_FEATURE(feat) __has_feature(feat)
#else
#define FK_YAML_HAS_FEATURE(feat) (0)
#endif

// switch usage of the no_sanitize attribute only when Clang sanitizer is active.
#if defined(__clang__) && FK_YAML_HAS_FEATURE(address_sanitizer)
#define FK_YAML_NO_SANITIZE(...) __attribute__((no_sanitize(__VA_ARGS__)))
#else
#define FK_YAML_NO_SANITIZE(...)
#endif

#if FK_YAML_HAS_INCLUDE(<version>)
// <version> is available since C++20
#include <version>
#endif

//
// C++ feature detections
//

// switch usages of the std::to_chars()/std::from_chars() functions which have been available since C++17.
#if defined(FK_YAML_HAS_CXX_17) && defined(__cpp_lib_to_chars) && __cpp_lib_to_chars >= 201611L
#define FK_YAML_HAS_TO_CHARS (1)
#else
#define FK_YAML_HAS_TO_CHARS (0)
#endif

// switch usage of char8_t which has been available since C++20.
#if defined(FK_YAML_HAS_CXX_20) && defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
#define FK_YAML_HAS_CHAR8_T (1)
#else
#define FK_YAML_HAS_CHAR8_T (0)
#endif

//
// utility macros
//

// switch usage of [[likely]] C++ attribute which has been available since C++20.
#if defined(FK_YAML_HAS_CXX_20) && FK_YAML_HAS_CPP_ATTRIBUTE(likely) >= 201803L
#define FK_YAML_LIKELY(expr) (!!(expr)) [[likely]]
#elif FK_YAML_HAS_BUILTIN(__builtin_expect)
#define FK_YAML_LIKELY(expr) (__builtin_expect(!!(expr), 1))
#else
#define FK_YAML_LIKELY(expr) (!!(expr))
#endif

// switch usage of [[unlikely]] C++ attribute which has been available since C++20.
#if defined(FK_YAML_HAS_CXX_20) && FK_YAML_HAS_CPP_ATTRIBUTE(unlikely) >= 201803L
#define FK_YAML_UNLIKELY(expr) (!!(expr)) [[unlikely]]
#elif FK_YAML_HAS_BUILTIN(__builtin_expect)
#define FK_YAML_UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
#else
#define FK_YAML_UNLIKELY(expr) (!!(expr))
#endif

#endif /* FK_YAML_DETAIL_MACROS_CPP_CONFIG_MACROS_HPP */


#endif /* FK_YAML_DETAIL_MACROS_DEFINE_MACROS_HPP */

// #include <fkYAML/detail/assert.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ASSERT_HPP
#define FK_YAML_DETAIL_ASSERT_HPP

// if FK_YAML_ASSERT is not user-defined. apply the default assert impl.
#ifndef FK_YAML_ASSERT
#ifndef NDEBUG
#include <cassert>
#define FK_YAML_ASSERT(x) assert(x)
#else
#define FK_YAML_ASSERT(x)
#endif
#endif

#endif /* FK_YAML_DETAIL_ASSERT_HPP */

// #include <fkYAML/detail/document_metainfo.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_DOCUMENT_METAINFO_HPP
#define FK_YAML_DETAIL_DOCUMENT_METAINFO_HPP

#include <string>
#include <map>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_META_NODE_TRAITS_HPP
#define FK_YAML_DETAIL_META_NODE_TRAITS_HPP

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/detect.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_META_DETECT_HPP
#define FK_YAML_DETAIL_META_DETECT_HPP

#include <iterator>
#include <type_traits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_META_STL_SUPPLEMENT_HPP
#define FK_YAML_DETAIL_META_STL_SUPPLEMENT_HPP

#include <cstddef>
#include <type_traits>

// #include <fkYAML/detail/macros/define_macros.hpp>


#ifdef FK_YAML_HAS_CXX_14
#include <utility>
#endif

FK_YAML_DETAIL_NAMESPACE_BEGIN

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//   For contributors:
//     This file is for supplementing future C++ STL implementations to utilize some useful features
//     implemented in C++14 or better.
//     This file is needed to keep the fkYAML library requirement to C++11.
//     **DO NOT** implement features which are not included any version of STL in this file.
//     Such implementations must be in the type_traits.hpp file.
/////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef FK_YAML_HAS_CXX_14

/// @brief An alias template for std::add_pointer::type with C++11.
/// @note std::add_pointer_t is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/add_pointer
/// @tparam T A type to be added a pointer.
template <typename T>
using add_pointer_t = typename std::add_pointer<T>::type;

/// @brief An alias template for std::enable_if::type with C++11.
/// @note std::enable_if_t is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/enable_if
/// @tparam Condition A condition tested at compile time.
/// @tparam T The type defined only if Condition is true.
template <bool Condition, typename T = void>
using enable_if_t = typename std::enable_if<Condition, T>::type;

/// @brief A simple implementation to use std::is_null_pointer with C++11.
/// @note std::is_null_pointer is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/is_null_pointer
/// @tparam T The type to be checked if it's equal to std::nullptr_t.
template <typename T>
struct is_null_pointer : std::is_same<std::nullptr_t, typename std::remove_cv<T>::type> {};

/// @brief An alias template for std::remove_cv::type with C++11.
/// @note std::remove_cv_t is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/remove_cv
/// @tparam T A type from which const-volatile qualifiers are removed.
template <typename T>
using remove_cv_t = typename std::remove_cv<T>::type;

/// @brief An alias template for std::remove_pointer::type with C++11.
/// @note std::remove_pointer_t is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/remove_pointer
/// @tparam T A type from which a pointer is removed.
template <typename T>
using remove_pointer_t = typename std::remove_pointer<T>::type;

/// @brief An alias template for std::remove_reference::type with C++11.
/// @note std::remove_reference_t is available since C++14.
/// @sa https://en.cppreference.com/w/cpp/types/remove_reference
/// @tparam T A type from which a reference is removed.
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;

template <typename T, T... I>
struct integer_sequence {
    using value_type = T;
    static constexpr std::size_t size() noexcept {
        return sizeof...(I);
    }
};

#if !FK_YAML_HAS_BUILTIN(__make_integer_seq) && !FK_YAML_HAS_BUILTIN(__integer_pack)

namespace make_int_seq_impl {

template <typename IntSeq0, typename IntSeq1>
struct merger;

template <typename T, T... Ints0, T... Ints1>
struct merger<integer_sequence<T, Ints0...>, integer_sequence<T, Ints1...>> {
    using type = integer_sequence<T, Ints0..., (sizeof...(Ints0) + Ints1)...>;
};

template <typename T, std::size_t Num>
struct generator {
    using type =
        typename merger<typename generator<T, Num / 2>::type, typename generator<T, Num - Num / 2>::type>::type;
};

template <typename T>
struct generator<T, 0> {
    using type = integer_sequence<T>;
};

template <typename T>
struct generator<T, 1> {
    using type = integer_sequence<T, 0>;
};

} // namespace make_int_seq_impl

#endif

template <typename T, T Num>
using make_integer_sequence
#if FK_YAML_HAS_BUILTIN(__make_integer_seq)
    // clang defines built-in __make_integer_seq to generate an integer sequence.
    = __make_integer_seq<integer_sequence, T, Num>;
#elif FK_YAML_HAS_BUILTIN(__integer_pack)
    // GCC or other compilers may implement built-in __integer_pack to generate an
    // integer sequence.
    = integer_sequence<T, __integer_pack(Num)...>;
#else
    // fallback to the library implementation of make_integer_sequence.
    = typename make_int_seq_impl::generator<T, Num>::type;
#endif

template <std::size_t... Idx>
using index_sequence = integer_sequence<std::size_t, Idx...>;

template <std::size_t Num>
using make_index_sequence = make_integer_sequence<std::size_t, Num>;

template <typename... Types>
using index_sequence_for = make_index_sequence<sizeof...(Types)>;

#else // !defined(FK_YAML_HAS_CXX_14)

using std::add_pointer_t;
using std::enable_if_t;
using std::index_sequence;
using std::index_sequence_for;
using std::integer_sequence;
using std::is_null_pointer;
using std::make_index_sequence;
using std::make_integer_sequence;
using std::remove_cv_t;
using std::remove_pointer_t;
using std::remove_reference_t;

#endif // !defined(FK_YAML_HAS_CXX_14)

#ifndef FK_YAML_HAS_CXX_17

/// @brief A simple implementation to use std::bool_constant with C++11/C++14.
/// @tparam Val
template <bool Val>
using bool_constant = std::integral_constant<bool, Val>;

/// @brief A simple implementation to use std::void_t with C++11/C++14.
/// @note
/// std::conjunction is available since C++17.
/// This is applied when no traits are specified as inputs.
/// @sa https://en.cppreference.com/w/cpp/types/conjunction
/// @tparam Traits Type traits to be checked if their ::value are all true.
template <typename... Traits>
struct conjunction : std::true_type {};

/// @brief A partial specialization of conjunction if only one Trait is given.
/// @tparam Trait Type trait to be checked if its ::value is true.
template <typename Trait>
struct conjunction<Trait> : Trait {};

/// @brief A partial specialization of conjunction if more than one traits are given.
/// @tparam First The first type trait to be checked if its ::value is true.
/// @tparam Rest The rest of traits passed as another conjunction template arguments if First::value is true.
template <typename First, typename... Rest>
struct conjunction<First, Rest...> : std::conditional<First::value, conjunction<Rest...>, First>::type {};

/// @brief A simple implementation to use std::disjunction with C++11/C++14.
/// @note
/// std::disjunction is available since C++17.
/// This is applied when no traits are specified as inputs.
/// @sa https://en.cppreference.com/w/cpp/types/disjunction
/// @tparam Traits Type traits to be checked if at least one of their ::value is true.
template <typename... Traits>
struct disjunction : std::false_type {};

/// @brief A partial specialization of disjunction if only one Trait is given.
/// @tparam Trait Type trait to be checked if its ::value is true.
template <typename Trait>
struct disjunction<Trait> : Trait {};

/// @brief A partial specialization of disjunction if more than one traits are given.
/// @tparam First The first type trait to be checked if its ::value is true.
/// @tparam Rest The rest of traits passed as another conjunction template arguments if First::value is false.
template <typename First, typename... Rest>
struct disjunction<First, Rest...> : std::conditional<First::value, First, disjunction<Rest...>>::type {};

/// @brief A simple implementation to use std::negation with C++11/C++14.
/// @note std::negation is available since C++17.
/// @sa https://en.cppreference.com/w/cpp/types/negation
/// @tparam Trait Type trait whose ::value is negated.
template <typename Trait>
struct negation : std::integral_constant<bool, !Trait::value> {};

/// @brief A helper for void_t.
/// @tparam Types Any types to be transformed to void type.
template <typename... Types>
struct make_void {
    using type = void;
};

/// @brief A simple implementation to use std::void_t with C++11/C++14.
/// @note std::void_t is available since C++17.
/// @sa https://en.cppreference.com/w/cpp/types/void_t
/// @tparam Types Any types to be transformed to void type.
template <typename... Types>
using void_t = typename make_void<Types...>::type;

#else // !defined(FK_YAML_HAS_CXX_17)

using std::bool_constant;
using std::conjunction;
using std::disjunction;
using std::negation;
using std::void_t;

#endif // !defined(FK_YAML_HAS_CXX_17)

#ifndef FK_YAML_HAS_CXX_20

/// @brief A simple implementation to use std::remove_cvref_t with C++11/C++14/C++17.
/// @note std::remove_cvref & std::remove_cvref_t are available since C++20.
/// @sa https://en.cppreference.com/w/cpp/types/remove_cvref
/// @tparam T A type from which cv-qualifiers and reference are removed.
template <typename T>
using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

#else

using std::remove_cvref_t;

#endif

/// @brief A wrapper function to call std::unreachable() (since C++23) or similar compiler specific extensions.
/// @note This function is implemented only for better code optimization against dead code and thus excluded from
/// coverage report.
// LCOV_EXCL_START
[[noreturn]] inline void unreachable() {
    // use compiler specific extensions if possible.
    // undefined behavior should be raised by an empty function with noreturn attribute.

#if defined(FK_YAML_HAS_CXX_23) || (defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L)
    std::unreachable();
#elif defined(_MSC_VER) && !defined(__clang__) // MSVC
    __assume(false);
#else
    __builtin_unreachable();
#endif
}
// LCOV_EXCL_STOP

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_META_STL_SUPPLEMENT_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A dummy struct to represent detection failure.
struct nonesuch {
    nonesuch() = delete;
    ~nonesuch() = delete;
    nonesuch(const nonesuch&) = delete;
    nonesuch(nonesuch&&) = delete;
    nonesuch& operator=(const nonesuch&) = delete;
    nonesuch& operator=(nonesuch&&) = delete;
};

/// @brief namespace to implement detector type traits
namespace detector_impl {

/// @brief A helper for general type detection.
/// @tparam Default A type to represent detection failure.
/// @tparam AlwaysVoid This must be void type.
/// @tparam Op A type for desired operation type.
/// @tparam Args Argument types passed to desired operation.
template <typename Default, typename AlwaysVoid, template <typename...> class Op, typename... Args>
struct detector : std::false_type {
    /// @brief A type which represents detection failure.
    using type = Default;
};

/// @brief A partial specialization of detector if desired operation type is found.
/// @tparam Default A type to represent detection failure.
/// @tparam Op A type for desired operation type.
/// @tparam Args Argument types passed to desired operation.
template <typename Default, template <typename...> class Op, typename... Args>
struct detector<Default, void_t<Op<Args...>>, Op, Args...> : std::true_type {
    /// @brief A detected type.
    using type = Op<Args...>;
};

} // namespace detector_impl

/// @brief Type traits to detect Op operation with Args argument types
/// @tparam Op A desired operation type.
/// @tparam Args Argument types passed to desired operation.
template <template <typename...> class Op, typename... Args>
using is_detected = detector_impl::detector<nonesuch, void, Op, Args...>;

/// @brief Type traits to represent a detected type.
/// @tparam Op A type for desired operation type.
/// @tparam Args Argument types passed to desired operation.
template <template <typename...> class Op, typename... Args>
using detected_t = typename detector_impl::detector<nonesuch, void, Op, Args...>::type;

/// @brief Type traits to check if Expected and a detected type are exactly the same.
/// @tparam Expected An expected detection result type.
/// @tparam Op A type for desired operation.
/// @tparam Args Argument types passed to desired operation.
template <typename Expected, template <typename...> class Op, typename... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;

/// @brief namespace for member type detections of aliases and functions.
namespace detect {

/// @brief The type which represents `iterator` member type.
/// @tparam T A target type.
template <typename T>
using iterator_t = typename T::iterator;

/// @brief The type which represents `key_type` member type.
/// @tparam T A target type.
template <typename T>
using key_type_t = typename T::key_type;

/// @brief The type which represents `mapped_type` member type.
/// @tparam T A target type.
template <typename T>
using mapped_type_t = typename T::mapped_type;

/// @brief The type which represents `value_type` member type.
/// @tparam T A target type.
template <typename T>
using value_type_t = typename T::value_type;

/// @brief The type which represents `difference_type` member type.
/// @tparam T A target type.
template <typename T>
using difference_type_t = typename T::difference_type;

/// @brief The type which represents `pointer` member type.
/// @tparam T A target type.
template <typename T>
using pointer_t = typename T::pointer;

/// @brief The type which represents `reference` member type.
/// @tparam T A target type.
template <typename T>
using reference_t = typename T::reference;

/// @brief The type which represents `iterator_category` member type.
/// @tparam T A target type.
template <typename T>
using iterator_category_t = typename T::iterator_category;

/// @brief The type which represents `container_type` member type.
/// @tparam T A target type.
template <typename T>
using container_type_t = typename T::container_type;

/// @brief The type which represents emplace member function.
/// @tparam T A target type.
template <typename T, typename... Args>
using emplace_fn_t = decltype(std::declval<T>().emplace(std::declval<Args>()...));

/// @brief The type which represents reserve member function.
/// @tparam T A target type.
template <typename T>
using reserve_fn_t = decltype(std::declval<T>().reserve(std::declval<typename remove_cvref_t<T>::size_type>()));

/// @brief Type traits to check if T has `iterator` member type.
/// @tparam T A target type.
template <typename T>
using has_iterator = is_detected<iterator_t, remove_cvref_t<T>>;

/// @brief Type traits to check if T has `key_type` member type.
/// @tparam T A target type.
template <typename T>
using has_key_type = is_detected<key_type_t, remove_cvref_t<T>>;

/// @brief Type traits to check if T has `mapped_type` member type.
/// @tparam T A target type.
template <typename T>
using has_mapped_type = is_detected<mapped_type_t, remove_cvref_t<T>>;

/// @brief Type traits to check if T has `value_type` member type.
/// @tparam T A target type.
template <typename T>
using has_value_type = is_detected<value_type_t, remove_cvref_t<T>>;

/// @brief Type traits to check if T is a std::iterator_traits like type.
/// @tparam T A target type.
template <typename T>
struct is_iterator_traits : conjunction<
                                is_detected<difference_type_t, remove_cvref_t<T>>, has_value_type<remove_cvref_t<T>>,
                                is_detected<pointer_t, remove_cvref_t<T>>, is_detected<reference_t, remove_cvref_t<T>>,
                                is_detected<iterator_category_t, remove_cvref_t<T>>> {};

/// @brief Type traits to check if T has `container_type` member type.
/// @tparam T A target type.
template <typename T>
using has_container_type = is_detected<container_type_t, remove_cvref_t<T>>;

/// @brief Type traits to check if T has reserve member function.
/// @tparam T A target type.
template <typename T>
using has_reserve = is_detected<reserve_fn_t, T>;

// fallback to these STL functions.
using std::begin;
using std::end;

/// @brief Type traits to check if begin/end functions can be called on a T object.
/// @tparam T A target type.
template <typename T, typename = void>
struct has_begin_end : std::false_type {};

/// @brief Type traits to check if begin/end functions can be called on a T object.
/// @tparam T A target type.
template <typename T>
struct has_begin_end<T, void_t<decltype(begin(std::declval<T>()), end(std::declval<T>()))>> : std::true_type {};

} // namespace detect

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_META_DETECT_HPP */

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_META_TYPE_TRAITS_HPP
#define FK_YAML_DETAIL_META_TYPE_TRAITS_HPP

#include <iterator>
#include <type_traits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Type trait to check if T and U are comparable types.
/// @tparam Comparator An object type to compare T and U objects.
/// @tparam T A type for comparison.
/// @tparam U The other type for comparison.
/// @tparam typename Placeholder for determining T and U are comparable types.
template <typename Comparator, typename T, typename U, typename = void>
struct is_comparable : std::false_type {};

/// @brief A partial specialization of is_comparable if T and U are comparable types.
/// @tparam Comparator An object type to compare T and U objects.
/// @tparam T A type for comparison.
/// @tparam U The other type for comparison.
template <typename Comparator, typename T, typename U>
struct is_comparable<
    Comparator, T, U,
    void_t<
        decltype(std::declval<Comparator>()(std::declval<T>(), std::declval<U>())),
        decltype(std::declval<Comparator>()(std::declval<U>(), std::declval<T>()))>> : std::true_type {};

/// @brief Type trait to check if KeyType can be used as key type.
/// @tparam Comparator An object type to compare T and U objects.
/// @tparam ObjectKeyType The original key type.
/// @tparam KeyType A type to be used as key type.
template <typename Comparator, typename ObjectKeyType, typename KeyType>
using is_usable_as_key_type = is_comparable<Comparator, ObjectKeyType, KeyType>;

/// @brief Type trait to check if T is of non-boolean integral types.
/// @tparam T A type to be checked.
template <typename T>
using is_non_bool_integral = conjunction<std::is_integral<T>, negation<std::is_same<bool, T>>>;

/// @brief Type traits to check if T is a complete type.
/// @tparam T A type to be checked if a complete type.
/// @tparam typename N/A
template <typename T, typename = void>
struct is_complete_type : std::false_type {};

/// @brief A partial specialization of is_complete_type if T is a complete type.
/// @tparam T
template <typename T>
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};

/// @brief A utility alias to test if the value type of `ItrType` is `T`.
/// @tparam ItrType An iterator type.
/// @tparam T The target iterator value type.
template <typename ItrType, typename T>
using is_iterator_of = std::is_same<remove_cv_t<typename std::iterator_traits<ItrType>::value_type>, T>;

/// @brief A utility struct to generate static constant instance.
/// @tparam T A target type for the resulting static constant instance.
template <typename T>
struct static_const {
    static FK_YAML_INLINE_VAR constexpr T value {}; // NOLINT(readability-identifier-naming)
};

#ifndef FK_YAML_HAS_CXX_17
/// @brief A instantiation of static_const::value instance.
/// @note This is required if inline variables are not available. C++11-14 do not provide such a feature yet.
/// @tparam T A target type for the resulting static constant instance.
template <typename T>
constexpr T static_const<T>::value;
#endif

/// @brief A helper structure for tag dispatch.
/// @tparam T A tag type.
template <typename T>
struct type_tag {
    /// @brief A tagged type.
    using type = T;
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_META_TYPE_TRAITS_HPP */

// #include <fkYAML/fkyaml_fwd.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_FKYAML_FWD_HPP
#define FK_YAML_FKYAML_FWD_HPP

#include <cstdint>
#include <map>
#include <string>
#include <vector>

// #include <fkYAML/detail/macros/version_macros.hpp>


FK_YAML_NAMESPACE_BEGIN

/// @brief An ADL friendly converter between basic_node objects and native data objects.
/// @tparam ValueType A target data type.
/// @sa https://fktn-k.github.io/fkYAML/api/node_value_converter/
template <typename ValueType, typename = void>
class node_value_converter;

/// @brief A class to store value of YAML nodes.
/// @sa https://fktn-k.github.io/fkYAML/api/basic_node/
template <
    template <typename, typename...> class SequenceType = std::vector,
    template <typename, typename, typename...> class MappingType = std::map, typename BooleanType = bool,
    typename IntegerType = std::int64_t, typename FloatNumberType = double, typename StringType = std::string,
    template <typename, typename = void> class ConverterType = node_value_converter>
class basic_node;

/// @brief default YAML node value container.
/// @sa https://fktn-k.github.io/fkYAML/api/basic_node/node/
using node = basic_node<>;

/// @brief A minimal map-like container which preserves insertion order.
/// @tparam Key A type for keys.
/// @tparam Value A type for values.
/// @tparam IgnoredCompare A placeholder for key comparison. This will be ignored.
/// @tparam Allocator A class for allocators.
/// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
template <typename Key, typename Value, typename IgnoredCompare, typename Allocator>
class ordered_map;

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_FKYAML_FWD_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/////////////////////////////
//   is_basic_node traits
/////////////////////////////

/// @brief Actual implementation of the is_basic_node type traits struct.
/// @tparam T A class to be checked if it's a basic_node template class instance type.
template <typename T>
struct is_basic_node_impl : std::false_type {};

/// @brief A partial specialization of is_basic_node_impl for basic_node template class.
/// @tparam SequenceType A type for sequence node value containers.
/// @tparam MappingType A type for mapping node value containers.
/// @tparam BooleanType A type for boolean node values.
/// @tparam IntegerType A type for integer node values.
/// @tparam FloatNumberType A type for float number node values.
/// @tparam StringType A type for string node values.
/// @tparam Converter A type for node-value converter
template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename> class Converter>
struct is_basic_node_impl<
    basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, Converter>>
    : std::true_type {};

/// @brief A struct to check the template parameter class is a basic_node template class instance type.
/// @tparam T A class to be checked if it's a basic_node template class instance type.
template <typename T>
struct is_basic_node : is_basic_node_impl<remove_cvref_t<T>> {};

///////////////////////////////////
//   is_node_ref_storage traits
///////////////////////////////////

// forward declaration for node_ref_storage<...>
template <typename>
class node_ref_storage;

/// @brief A struct to check the template parameter class is a kind of node_ref_storage_template class.
/// @tparam T A type to be checked if it's a kind of node_ref_storage template class.
template <typename T>
struct is_node_ref_storage : std::false_type {};

/// @brief A partial specialization for node_ref_storage template class.
/// @tparam T A template parameter type of node_ref_storage template class.
template <typename T>
struct is_node_ref_storage<node_ref_storage<T>> : std::true_type {};

///////////////////////////////////////////////////////
//   basic_node conversion API representative types
///////////////////////////////////////////////////////

/// @brief A type represent from_node function.
/// @tparam T A type which provides from_node function.
/// @tparam Args Argument types passed to from_node function.
template <typename T, typename... Args>
using from_node_function_t = decltype(T::from_node(std::declval<Args>()...));

/// @brief A type which represent to_node function.
/// @tparam T A type which provides to_node function.
/// @tparam Args Argument types passed to to_node function.
template <typename T, typename... Args>
using to_node_function_t = decltype(T::to_node(std::declval<Args>()...));

///////////////////////////////////////////////////
//   basic_node conversion API detection traits
///////////////////////////////////////////////////

/// @brief Type traits to check if T is a compatible type for BasicNodeType in terms of from_node function.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A target type passed to from_node function.
/// @tparam typename N/A
template <typename BasicNodeType, typename T, typename = void>
struct has_from_node : std::false_type {};

/// @brief A partial specialization of has_from_node if T is not a basic_node template instance type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A target type passed to from_node function.
template <typename BasicNodeType, typename T>
struct has_from_node<BasicNodeType, T, enable_if_t<negation<is_basic_node<T>>::value>> {
    using converter = typename BasicNodeType::template value_converter_type<T, void>;

    // NOLINTNEXTLINE(readability-identifier-naming)
    static constexpr bool value =
        is_detected_exact<void, from_node_function_t, converter, const BasicNodeType&, T&>::value;
};

/// @brief Type traits to check if T is a compatible type for BasicNodeType in terms of to_node function.
/// @warning Do not pass basic_node type as BasicNodeType to avoid infinite type instantiation.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A target type passed to to_node function.
/// @tparam typename N/A
template <typename BasicNodeType, typename T, typename = void>
struct has_to_node : std::false_type {};

/// @brief A partial specialization of has_to_node if T is not a basic_node template instance type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A target type passed to to_node function.
template <typename BasicNodeType, typename T>
struct has_to_node<BasicNodeType, T, enable_if_t<negation<is_basic_node<T>>::value>> {
    using converter = typename BasicNodeType::template value_converter_type<T, void>;

    // NOLINTNEXTLINE(readability-identifier-naming)
    static constexpr bool value = is_detected_exact<void, to_node_function_t, converter, BasicNodeType&, T>::value;
};

///////////////////////////////////////
//   is_node_compatible_type traits
///////////////////////////////////////

/// @brief Type traits implementation of is_node_compatible_type to check if CompatibleType is a compatible type for
/// BasicNodeType.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatibleType A target type for compatibility check.
/// @tparam typename N/A
template <typename BasicNodeType, typename CompatibleType, typename = void>
struct is_node_compatible_type_impl : std::false_type {};

/// @brief A partial specialization of is_node_compatible_type_impl if CompatibleType is a complete type and is
/// compatible for BasicNodeType.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatibleType A target type for compatibility check.
template <typename BasicNodeType, typename CompatibleType>
struct is_node_compatible_type_impl<
    BasicNodeType, CompatibleType,
    enable_if_t<conjunction<is_complete_type<CompatibleType>, has_to_node<BasicNodeType, CompatibleType>>::value>>
    : std::true_type {};

/// @brief Type traits to check if CompatibleType is a compatible type for BasicNodeType.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatibleType A target type for compatibility check.
template <typename BasicNodeType, typename CompatibleType>
struct is_node_compatible_type : is_node_compatible_type_impl<BasicNodeType, CompatibleType> {};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_META_NODE_TRAITS_HPP */

// #include <fkYAML/yaml_version_type.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_YAML_VERSION_TYPE_HPP
#define FK_YAML_YAML_VERSION_TYPE_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>


FK_YAML_NAMESPACE_BEGIN

enum class yaml_version_type : std::uint8_t {
    VERSION_1_1, //!< YAML version 1.1
    VERSION_1_2, //!< YAML version 1.2
};

inline const char* to_string(yaml_version_type t) noexcept {
    switch (t) {
    case yaml_version_type::VERSION_1_1:
        return "VERSION_1_1";
    case yaml_version_type::VERSION_1_2:
        return "VERSION_1_2";
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_YAML_VERSION_TYPE_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief The set of directives for a YAML document.
template <typename BasicNodeType, typename = enable_if_t<is_basic_node<BasicNodeType>::value>>
struct document_metainfo {
    /// The YAML version used for the YAML document.
    yaml_version_type version {yaml_version_type::VERSION_1_2};
    /// Whether the YAML version has been specified.
    bool is_version_specified {false};
    /// The prefix of the primary handle.
    std::string primary_handle_prefix;
    /// The prefix of the secondary handle.
    std::string secondary_handle_prefix;
    /// The map of handle-prefix pairs.
    std::map<std::string /*handle*/, std::string /*prefix*/> named_handle_map;
    /// The map of anchor node which allows for key duplication.
    std::multimap<std::string /*anchor name*/, BasicNodeType> anchor_table {};
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_DOCUMENT_METAINFO_HPP */

// #include <fkYAML/detail/exception_safe_allocation.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_EXCEPTION_SAFE_ALLOCATION_HPP
#define FK_YAML_DETAIL_EXCEPTION_SAFE_ALLOCATION_HPP

#include <memory>
#include <utility>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Helper struct which ensures destruction/deallocation of heap-allocated objects.
/// @tparam ObjT Object type.
/// @tparam AllocTraits Allocator traits type for the object.
template <typename ObjT, typename AllocTraits>
struct tidy_guard {
    tidy_guard() = delete;

    /// @brief Construct a tidy_guard with a pointer to the object.
    /// @param p_obj
    tidy_guard(ObjT* p_obj) noexcept
        : p_obj(p_obj) {
    }

    // move-only
    tidy_guard(const tidy_guard&) = delete;
    tidy_guard& operator=(const tidy_guard&) = delete;

    /// @brief Move constructs a tidy_guard object.
    tidy_guard(tidy_guard&&) = default;

    /// @brief Move assigns a tidy_guard object.
    /// @return Reference to this tidy_guard object.
    tidy_guard& operator=(tidy_guard&&) = default;

    /// @brief Destroys this tidy_guard object. Destruction/deallocation happen if the pointer is not null.
    ~tidy_guard() {
        if FK_YAML_UNLIKELY (p_obj != nullptr) {
            typename AllocTraits::allocator_type alloc {};
            AllocTraits::destroy(alloc, p_obj);
            AllocTraits::deallocate(alloc, p_obj, 1);
            p_obj = nullptr;
        }
    }

    /// @brief Get the pointer to the object.
    /// @return The pointer to the object.
    ObjT* get() const noexcept {
        return p_obj;
    }

    /// @brief Checks if the pointer is not null.
    explicit operator bool() const noexcept {
        return p_obj != nullptr;
    }

    /// @brief Releases the pointer to the object. No destruction/deallocation happen after this function gets called.
    /// @return The pointer to the object.
    ObjT* release() noexcept {
        ObjT* ret = p_obj;
        p_obj = nullptr;
        return ret;
    }

    /// @brief The pointer to the object.
    ObjT* p_obj {nullptr};
};

/// @brief Allocates and constructs an `ObjT` object with given arguments.
/// @tparam ObjT The object type.
/// @tparam ...Args The argument types.
/// @param ...args The arguments for construction.
/// @return An address of allocated memory on the heap.
template <typename ObjT, typename... Args>
inline ObjT* create_object(Args&&... args) {
    using alloc_type = std::allocator<ObjT>;
    using alloc_traits_type = std::allocator_traits<alloc_type>;

    alloc_type alloc {};
    tidy_guard<ObjT, alloc_traits_type> tg {alloc_traits_type::allocate(alloc, 1)};
    alloc_traits_type::construct(alloc, tg.get(), std::forward<Args>(args)...);

    FK_YAML_ASSERT(tg);
    return tg.release();
}

/// @brief Destroys and deallocates an `ObjT` object.
/// @tparam ObjT The object type.
/// @param p_obj A pointer to the object.
template <typename ObjT>
inline void destroy_object(ObjT* p_obj) {
    FK_YAML_ASSERT(p_obj != nullptr);
    std::allocator<ObjT> alloc;
    std::allocator_traits<decltype(alloc)>::destroy(alloc, p_obj);
    std::allocator_traits<decltype(alloc)>::deallocate(alloc, p_obj, 1);
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_EXCEPTION_SAFE_ALLOCATION_HPP */

// #include <fkYAML/detail/input/deserializer.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_DESERIALIZER_HPP
#define FK_YAML_DETAIL_INPUT_DESERIALIZER_HPP

#include <algorithm>
#include <deque>
#include <vector>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/document_metainfo.hpp>

// #include <fkYAML/detail/input/lexical_analyzer.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_LEXICAL_ANALYZER_HPP
#define FK_YAML_DETAIL_INPUT_LEXICAL_ANALYZER_HPP

#include <algorithm>
#include <cctype>
#include <cstdlib>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/detail/encodings/uri_encoding.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ENCODINGS_URI_ENCODING_HPP
#define FK_YAML_DETAIL_ENCODINGS_URI_ENCODING_HPP

#include <cctype>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A class which handles URI encodings.
class uri_encoding {
public:
    /// @brief Validates the encoding of the given character sequence.
    /// @param begin An iterator to the first element of the character sequence.
    /// @param end An iterator to the past-the-end element of the character sequence.
    /// @return true if all the characters are valid, false otherwise.
    static bool validate(const char* begin, const char* end) noexcept {
        if (begin == end) {
            return true;
        }

        const char* current = begin;

        for (; current != end; ++current) {
            if (*current == '%') {
                const bool are_valid_octets = validate_octets(++current, end);
                if (!are_valid_octets) {
                    return false;
                }

                continue;
            }

            const bool is_allowed_character = validate_character(*current);
            if (!is_allowed_character) {
                return false;
            }
        }

        return true;
    }

private:
    /// @brief Validates the given octets.
    /// @param begin An iterator to the first octet.
    /// @param end An iterator to the past-the-end element of the whole character sequence.
    /// @return true if the octets are valid, false otherwise.
    static bool validate_octets(const char*& begin, const char*& end) {
        for (int i = 0; i < 2; i++, ++begin) {
            if (begin == end) {
                return false;
            }

            // Normalize a character for a-f/A-F comparison
            const int octet = std::tolower(*begin);

            if ('0' <= octet && octet <= '9') {
                continue;
            }

            if ('a' <= octet && octet <= 'f') {
                continue;
            }

            return false;
        }

        return true;
    }

    /// @brief Verify if the given character is allowed as a URI character.
    /// @param c The target character.
    /// @return true if the given character is allowed as a URI character, false otherwise.
    static bool validate_character(const char c) {
        // Check if the current character is one of reserved/unreserved characters which are allowed for
        // use. See the following links for details:
        // * reserved characters:   https://datatracker.ietf.org/doc/html/rfc3986#section-2.2
        // * unreserved characters: https://datatracker.ietf.org/doc/html/rfc3986#section-2.3

        switch (c) {
        // reserved characters (gen-delims)
        case ':':
        case '/':
        case '?':
        case '#':
        case '[':
        case ']':
        case '@':
        // reserved characters (sub-delims)
        case '!':
        case '$':
        case '&':
        case '\'':
        case '(':
        case ')':
        case '*':
        case '+':
        case ',':
        case ';':
        case '=':
        // unreserved characters
        case '-':
        case '.':
        case '_':
        case '~':
            return true;
        default:
            // alphabets and numbers are also allowed.
            return static_cast<bool>(std::isalnum(c));
        }
    }
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_ENCODINGS_URI_ENCODING_HPP */

// #include <fkYAML/detail/encodings/utf_encodings.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODINGS_HPP
#define FK_YAML_DETAIL_ENCODINGS_UTF_ENCODINGS_HPP

#include <array>
#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/exception.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_EXCEPTION_HPP
#define FK_YAML_EXCEPTION_HPP

#include <array>
#include <initializer_list>
#include <stdexcept>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/string_formatter.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_STRING_FORMATTER_HPP
#define FK_YAML_DETAIL_STRING_FORMATTER_HPP

#include <cstdarg>
#include <cstdio>
#include <memory>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

// NOLINTNEXTLINE(cert-dcl50-cpp)
inline std::string format(const char* fmt, ...) {
    // NOLINTBEGIN(cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay)
    va_list vl;
    va_start(vl, fmt);
    int size = std::vsnprintf(nullptr, 0, fmt, vl);
    va_end(vl);

    // LCOV_EXCL_START
    if (size < 0) {
        return "";
    }
    // LCOV_EXCL_STOP

    const std::unique_ptr<char[]> buffer {new char[size + 1] {}};

    va_start(vl, fmt);
    size = std::vsnprintf(buffer.get(), size + 1, fmt, vl);
    va_end(vl);
    // NOLINTEND(cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay)

    return {buffer.get(), static_cast<std::size_t>(size)};
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_STRING_FORMATTER_HPP */

// #include <fkYAML/detail/types/node_t.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_TYPES_NODE_T_HPP
#define FK_YAML_DETAIL_TYPES_NODE_T_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/node_type.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_NODE_TYPE_HPP
#define FK_YAML_NODE_TYPE_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>


FK_YAML_NAMESPACE_BEGIN

enum class node_type : std::uint8_t {
    SEQUENCE,    //!< sequence value type
    MAPPING,     //!< mapping value type
    NULL_OBJECT, //!< null value type
    BOOLEAN,     //!< boolean value type
    INTEGER,     //!< integer value type
    FLOAT,       //!< float point value type
    STRING,      //!< string value type
};

inline const char* to_string(node_type t) noexcept {
    switch (t) {
    case node_type::SEQUENCE:
        return "SEQUENCE";
    case node_type::MAPPING:
        return "MAPPING";
    case node_type::NULL_OBJECT:
        return "NULL_OBJECT";
    case node_type::BOOLEAN:
        return "BOOLEAN";
    case node_type::INTEGER:
        return "INTEGER";
    case node_type::FLOAT:
        return "FLOAT";
    case node_type::STRING:
        return "STRING";
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_NODE_TYPE_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of node value types.
enum class node_t : std::uint8_t {
    SEQUENCE,     //!< sequence value type
    MAPPING,      //!< mapping value type
    NULL_OBJECT,  //!< null value type
    BOOLEAN,      //!< boolean value type
    INTEGER,      //!< integer value type
    FLOAT_NUMBER, //!< float number value type
    STRING,       //!< string value type
};

inline const char* to_string(node_t t) noexcept {
    switch (t) {
    case node_t::SEQUENCE:
        return "sequence";
    case node_t::MAPPING:
        return "mapping";
    case node_t::NULL_OBJECT:
        return "null";
    case node_t::BOOLEAN:
        return "boolean";
    case node_t::INTEGER:
        return "integer";
    case node_t::FLOAT_NUMBER:
        return "float";
    case node_t::STRING:
        return "string";
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

inline node_t convert_from_node_type(node_type t) {
    switch (t) {
    case node_type::SEQUENCE:
        return node_t::SEQUENCE;
    case node_type::MAPPING:
        return node_t::MAPPING;
    case node_type::NULL_OBJECT:
        return node_t::NULL_OBJECT;
    case node_type::BOOLEAN:
        return node_t::BOOLEAN;
    case node_type::INTEGER:
        return node_t::INTEGER;
    case node_type::FLOAT:
        return node_t::FLOAT_NUMBER;
    case node_type::STRING:
        return node_t::STRING;
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

inline node_type convert_to_node_type(node_t t) {
    switch (t) {
    case node_t::SEQUENCE:
        return node_type::SEQUENCE;
    case node_t::MAPPING:
        return node_type::MAPPING;
    case node_t::NULL_OBJECT:
        return node_type::NULL_OBJECT;
    case node_t::BOOLEAN:
        return node_type::BOOLEAN;
    case node_t::INTEGER:
        return node_type::INTEGER;
    case node_t::FLOAT_NUMBER:
        return node_type::FLOAT;
    case node_t::STRING:
        return node_type::STRING;
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_TYPES_NODE_T_HPP */


FK_YAML_NAMESPACE_BEGIN

/// @brief A base exception class used in fkYAML library.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/
class exception : public std::exception {
public:
    /// @brief Construct a new exception object without any error messages.
    /// @sa https://fktn-k.github.io/fkYAML/api/exception/constructor/
    exception() = default;

    /// @brief Construct a new exception object with an error message.
    /// @param[in] msg An error message.
    /// @sa https://fktn-k.github.io/fkYAML/api/exception/constructor/
    explicit exception(const char* msg) noexcept {
        if (msg) {
            m_error_msg = msg;
        }
    }

public:
    /// @brief Returns an error message internally held. If nothing, a non-null, empty string will be returned.
    /// @return An error message internally held. The message might be empty.
    /// @sa https://fktn-k.github.io/fkYAML/api/exception/what/
    const char* what() const noexcept override {
        return m_error_msg.c_str();
    }

private:
    /// An error message holder.
    std::string m_error_msg;
};

/// @brief An exception class indicating an encoding error.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/invalid_encoding/
class invalid_encoding : public exception {
public:
    /// @brief Construct a new invalid_encoding object for UTF-8 related errors.
    /// @param msg An error message.
    /// @param u8 The UTF-8 character bytes.
    explicit invalid_encoding(const char* msg, const std::initializer_list<uint8_t>& u8) noexcept
        : exception(generate_error_message(msg, u8).c_str()) {
    }

    /// @brief Construct a new invalid_encoding object for UTF-16 related errors.
    /// @param msg An error message.
    /// @param u16_h The first UTF-16 encoded element used for the UTF-8 encoding.
    /// @param u16_l The second UTF-16 encoded element used for the UTF-8 encoding.
    explicit invalid_encoding(const char* msg, std::array<char16_t, 2> u16) noexcept
        : exception(generate_error_message(msg, u16).c_str()) {
    }

    /// @brief Construct a new invalid_encoding object for UTF-32 related errors.
    /// @param msg An error message.
    /// @param u32 The UTF-32 encoded element used for the UTF-8 encoding.
    explicit invalid_encoding(const char* msg, char32_t u32) noexcept
        : exception(generate_error_message(msg, u32).c_str()) {
    }

private:
    static std::string generate_error_message(const char* msg, const std::initializer_list<uint8_t>& u8) noexcept {
        const auto* itr = u8.begin();
        const auto* end_itr = u8.end();
        std::string formatted = detail::format("invalid_encoding: %s in=[ 0x%02x", msg, *itr++);
        while (itr != end_itr) {
            formatted += detail::format(", 0x%02x", *itr++);
        }
        formatted += " ]";
        return formatted;
    }

    /// @brief Generate an error message from the given parameters for the UTF-16 encoding.
    /// @param msg An error message.
    /// @param h The first UTF-16 encoded element used for the UTF-8 encoding.
    /// @param l The second UTF-16 encoded element used for the UTF-8 encoding.
    /// @return A generated error message.
    static std::string generate_error_message(const char* msg, std::array<char16_t, 2> u16) noexcept {
        // uint16_t is large enough for UTF-16 encoded elements.
        return detail::format(
            "invalid_encoding: %s in=[ 0x%04x, 0x%04x ]",
            msg,
            static_cast<uint16_t>(u16[0]),
            static_cast<uint16_t>(u16[1]));
    }

    /// @brief Generate an error message from the given parameters for the UTF-32 encoding.
    /// @param msg An error message.
    /// @param u32 The UTF-32 encoded element used for the UTF-8 encoding.
    /// @return A generated error message.
    static std::string generate_error_message(const char* msg, char32_t u32) noexcept {
        // uint32_t is large enough for UTF-32 encoded elements.
        return detail::format("invalid_encoding: %s in=0x%08x", msg, static_cast<uint32_t>(u32));
    }
};

/// @brief An exception class indicating an error in parsing.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/parse_error/
class parse_error : public exception {
public:
    /// @brief Constructs a new parse_error object with an error message and counts of lines and columns at the error.
    /// @param[in] msg An error message.
    /// @param[in] lines Count of lines.
    /// @param[in] cols_in_line Count of columns.
    explicit parse_error(const char* msg, uint32_t lines, uint32_t cols_in_line) noexcept
        : exception(generate_error_message(msg, lines, cols_in_line).c_str()) {
    }

private:
    static std::string generate_error_message(const char* msg, uint32_t lines, uint32_t cols_in_line) noexcept {
        return detail::format("parse_error: %s (at line %u, column %u)", msg, lines, cols_in_line);
    }
};

/// @brief An exception class indicating an invalid type conversion.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/type_error/
class type_error : public exception {
public:
    /// @brief Construct a new type_error object with an error message and a node type.
    /// @param[in] msg An error message.
    /// @param[in] type The type of a source node value.
    explicit type_error(const char* msg, node_type type) noexcept
        : exception(generate_error_message(msg, type).c_str()) {
    }

    /// @brief Construct a new type_error object with an error message and a node type.
    /// @deprecated Use type_error(const char*, node_type) constructor. (since 0.3.12).
    /// @param[in] msg An error message.
    /// @param[in] type The type of a source node value.
    FK_YAML_DEPRECATED("Since 0.3.12; Use explicit type_error(const char*, node_type)")
    explicit type_error(const char* msg, detail::node_t type) noexcept
        : type_error(msg, detail::convert_to_node_type(type)) {
    }

private:
    /// @brief Generate an error message from given parameters.
    /// @param msg An error message.
    /// @param type The type of a source node value.
    /// @return A generated error message.
    static std::string generate_error_message(const char* msg, node_type type) noexcept {
        return detail::format("type_error: %s type=%s", msg, to_string(type));
    }
};

/// @brief An exception class indicating an out-of-range error.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/out_of_range/
class out_of_range : public exception {
public:
    /// @brief Construct a new out_of_range object with an invalid index value.
    /// @param[in] index An invalid index value.
    explicit out_of_range(int index) noexcept
        : exception(generate_error_message(index).c_str()) {
    }

    /// @brief Construct a new out_of_range object with invalid key contents.
    /// @param[in] key Invalid key contents
    explicit out_of_range(const char* key) noexcept
        : exception(generate_error_message(key).c_str()) {
    }

private:
    static std::string generate_error_message(int index) noexcept {
        return detail::format("out_of_range: index %d is out of range", index);
    }

    static std::string generate_error_message(const char* key) noexcept {
        return detail::format("out_of_range: key \'%s\' is not found.", key);
    }
};

/// @brief An exception class indicating an invalid tag.
/// @sa https://fktn-k.github.io/fkYAML/api/exception/invalid_tag/
class invalid_tag : public exception {
public:
    /// @brief Constructs a new invalid_tag object with an error message and invalid tag contents.
    /// @param[in] msg An error message.
    /// @param[in] tag Invalid tag contents.
    explicit invalid_tag(const char* msg, const char* tag)
        : exception(generate_error_message(msg, tag).c_str()) {
    }

private:
    static std::string generate_error_message(const char* msg, const char* tag) noexcept {
        return detail::format("invalid_tag: %s tag=%s", msg, tag);
    }
};

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_EXCEPTION_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/////////////////////////
//   UTF-8 Encoding   ///
/////////////////////////

/// @brief A class which handles UTF-8 encodings.
namespace utf8 {

/// @brief Query the number of UTF-8 character bytes with the first byte.
/// @param first_byte The first byte of a UTF-8 character.
/// @return The number of UTF-8 character bytes.
inline uint32_t get_num_bytes(uint8_t first_byte) {
    // The first byte starts with 0b0XXX'XXXX -> 1-byte character
    if FK_YAML_LIKELY (first_byte < 0x80) {
        return 1;
    }
    // The first byte starts with 0b110X'XXXX -> 2-byte character
    if ((first_byte & 0xE0) == 0xC0) {
        return 2;
    }
    // The first byte starts with 0b1110'XXXX -> 3-byte character
    if ((first_byte & 0xF0) == 0xE0) {
        return 3;
    }
    // The first byte starts with 0b1111'0XXX -> 4-byte character
    if ((first_byte & 0xF8) == 0xF0) {
        return 4;
    }

    // The first byte starts with 0b10XX'XXXX or 0b1111'1XXX -> invalid
    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first_byte});
}

/// @brief Checks if `byte` is a valid 1-byte UTF-8 character.
/// @param[in] byte The byte value.
/// @return true if `byte` is a valid 1-byte UTF-8 character, false otherwise.
inline bool validate(uint8_t byte) noexcept {
    // U+0000..U+007F
    return byte <= 0x7Fu;
}

/// @brief Checks if the given bytes are a valid 2-byte UTF-8 character.
/// @param[in] byte0 The first byte value.
/// @param[in] byte1 The second byte value.
/// @return true if the given bytes a valid 3-byte UTF-8 character, false otherwise.
inline bool validate(uint8_t byte0, uint8_t byte1) noexcept {
    // U+0080..U+07FF
    //   1st Byte: 0xC2..0xDF
    //   2nd Byte: 0x80..0xBF
    if FK_YAML_LIKELY (0xC2u <= byte0 && byte0 <= 0xDFu) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0xBFu) {
            return true;
        }
    }

    // The rest of byte combinations are invalid.
    return false;
}

/// @brief Checks if the given bytes are a valid 3-byte UTF-8 character.
/// @param[in] byte0 The first byte value.
/// @param[in] byte1 The second byte value.
/// @param[in] byte2 The third byte value.
/// @return true if the given bytes a valid 2-byte UTF-8 character, false otherwise.
inline bool validate(uint8_t byte0, uint8_t byte1, uint8_t byte2) noexcept {
    // U+1000..U+CFFF:
    //   1st Byte: 0xE0..0xEC
    //   2nd Byte: 0x80..0xBF
    //   3rd Byte: 0x80..0xBF
    if (0xE0u <= byte0 && byte0 <= 0xECu) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0xBFu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                return true;
            }
        }
        return false;
    }

    // U+D000..U+D7FF:
    //   1st Byte: 0xED
    //   2nd Byte: 0x80..0x9F
    //   3rd Byte: 0x80..0xBF
    if (byte0 == 0xEDu) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0x9Fu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                return true;
            }
        }
        return false;
    }

    // U+E000..U+FFFF:
    //   1st Byte: 0xEE..0xEF
    //   2nd Byte: 0x80..0xBF
    //   3rd Byte: 0x80..0xBF
    if FK_YAML_LIKELY (byte0 == 0xEEu || byte0 == 0xEFu) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0xBFu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                return true;
            }
        }
    }

    // The rest of byte combinations are invalid.
    return false;
}

/// @brief Checks if the given bytes are a valid 4-byte UTF-8 character.
/// @param[in] byte0 The first byte value.
/// @param[in] byte1 The second byte value.
/// @param[in] byte2 The third byte value.
/// @param[in] byte3 The fourth byte value.
/// @return true if the given bytes a valid 4-byte UTF-8 character, false otherwise.
inline bool validate(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3) noexcept {
    // U+10000..U+3FFFF:
    //   1st Byte: 0xF0
    //   2nd Byte: 0x90..0xBF
    //   3rd Byte: 0x80..0xBF
    //   4th Byte: 0x80..0xBF
    if (byte0 == 0xF0u) {
        if FK_YAML_LIKELY (0x90u <= byte1 && byte1 <= 0xBFu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                if FK_YAML_LIKELY (0x80u <= byte3 && byte3 <= 0xBFu) {
                    return true;
                }
            }
        }
        return false;
    }

    // U+40000..U+FFFFF:
    //   1st Byte: 0xF1..0xF3
    //   2nd Byte: 0x80..0xBF
    //   3rd Byte: 0x80..0xBF
    //   4th Byte: 0x80..0xBF
    if (0xF1u <= byte0 && byte0 <= 0xF3u) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0xBFu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                if FK_YAML_LIKELY (0x80u <= byte3 && byte3 <= 0xBFu) {
                    return true;
                }
            }
        }
        return false;
    }

    // U+100000..U+10FFFF:
    //   1st Byte: 0xF4
    //   2nd Byte: 0x80..0x8F
    //   3rd Byte: 0x80..0xBF
    //   4th Byte: 0x80..0xBF
    if FK_YAML_LIKELY (byte0 == 0xF4u) {
        if FK_YAML_LIKELY (0x80u <= byte1 && byte1 <= 0x8Fu) {
            if FK_YAML_LIKELY (0x80u <= byte2 && byte2 <= 0xBFu) {
                if FK_YAML_LIKELY (0x80u <= byte3 && byte3 <= 0xBFu) {
                    return true;
                }
            }
        }
    }

    // The rest of byte combinations are invalid.
    return false;
}

/// @brief Converts UTF-16 encoded characters to UTF-8 encoded bytes.
/// @param[in] utf16 UTF-16 encoded character(s).
/// @param[out] utf8 UTF-8 encoded bytes.
/// @param[out] consumed_size The number of UTF-16 encoded characters used for the conversion.
/// @param[out] encoded_size The size of UTF-encoded bytes.
inline void from_utf16(
    std::array<char16_t, 2> utf16, std::array<uint8_t, 4>& utf8, uint32_t& consumed_size, uint32_t& encoded_size) {
    const auto first = utf16[0];
    const auto second = utf16[1];
    if (first < 0x80u) {
        utf8[0] = static_cast<uint8_t>(first & 0x7Fu);
        consumed_size = 1;
        encoded_size = 1;
    }
    else if (first <= 0x7FFu) {
        const auto utf8_chunk = static_cast<uint16_t>(0xC080u | ((first & 0x07C0u) << 2) | (first & 0x3Fu));
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[1] = static_cast<uint8_t>(utf8_chunk);
        consumed_size = 1;
        encoded_size = 2;
    }
    else if (first < 0xD800u || 0xE000u <= first) {
        const uint32_t utf8_chunk = 0xE08080u | ((first & 0xF000u) << 4) | ((first & 0x0FC0u) << 2) | (first & 0x3Fu);
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 16);
        utf8[1] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[2] = static_cast<uint8_t>(utf8_chunk);
        consumed_size = 1;
        encoded_size = 3;
    }
    else if (first <= 0xDBFFu && 0xDC00u <= second && second <= 0xDFFFu) {
        // surrogate pair
        const uint32_t code_point = 0x10000u + ((first & 0x03FFu) << 10) + (second & 0x03FFu);
        const uint32_t utf8_chunk = 0xF0808080u | ((code_point & 0x1C0000u) << 6) | ((code_point & 0x03F000u) << 4) |
                                    ((code_point & 0x0FC0u) << 2) | (code_point & 0x3Fu);
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 24);
        utf8[1] = static_cast<uint8_t>(utf8_chunk >> 16);
        utf8[2] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[3] = static_cast<uint8_t>(utf8_chunk);
        consumed_size = 2;
        encoded_size = 4;
    }
    else {
        throw invalid_encoding("Invalid UTF-16 encoding detected.", utf16);
    }
}

/// @brief Converts a UTF-32 encoded character to UTF-8 encoded bytes.
/// @param[in] utf32 A UTF-32 encoded character.
/// @param[out] utf8 UTF-8 encoded bytes.
/// @param[in] encoded_size The size of UTF-encoded bytes.
inline void from_utf32(const char32_t utf32, std::array<uint8_t, 4>& utf8, uint32_t& encoded_size) {
    if (utf32 < 0x80u) {
        utf8[0] = static_cast<uint8_t>(utf32 & 0x007F);
        encoded_size = 1;
    }
    else if (utf32 <= 0x7FFu) {
        const auto utf8_chunk = static_cast<uint16_t>(0xC080u | ((utf32 & 0x07C0u) << 2) | (utf32 & 0x3Fu));
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[1] = static_cast<uint8_t>(utf8_chunk);
        encoded_size = 2;
    }
    else if (utf32 <= 0xFFFFu) {
        const uint32_t utf8_chunk = 0xE08080u | ((utf32 & 0xF000u) << 4) | ((utf32 & 0x0FC0u) << 2) | (utf32 & 0x3F);
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 16);
        utf8[1] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[2] = static_cast<uint8_t>(utf8_chunk);
        encoded_size = 3;
    }
    else if (utf32 <= 0x10FFFFu) {
        const uint32_t utf8_chunk = 0xF0808080u | ((utf32 & 0x1C0000u) << 6) | ((utf32 & 0x03F000u) << 4) |
                                    ((utf32 & 0x0FC0u) << 2) | (utf32 & 0x3Fu);
        utf8[0] = static_cast<uint8_t>(utf8_chunk >> 24);
        utf8[1] = static_cast<uint8_t>(utf8_chunk >> 16);
        utf8[2] = static_cast<uint8_t>(utf8_chunk >> 8);
        utf8[3] = static_cast<uint8_t>(utf8_chunk);
        encoded_size = 4;
    }
    else {
        throw invalid_encoding("Invalid UTF-32 encoding detected.", utf32);
    }
}

} // namespace utf8

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_ENCODINGS_UTF_ENCODINGS_HPP */

// #include <fkYAML/detail/input/block_scalar_header.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_BLOCK_SCALAR_HEADER_HPP
#define FK_YAML_DETAIL_INPUT_BLOCK_SCALAR_HEADER_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of chomping indicator types.
enum class chomping_indicator_t : std::uint8_t {
    STRIP, //!< excludes final line breaks and trailing empty lines indicated by `-`.
    CLIP,  //!< preserves final line breaks but excludes trailing empty lines. no indicator means this type.
    KEEP,  //!< preserves final line breaks and trailing empty lines indicated by `+`.
};

/// @brief Block scalar header information.
struct block_scalar_header {
    /// Chomping indicator type.
    chomping_indicator_t chomp {chomping_indicator_t::CLIP};
    /// Content indentation level of a block scalar.
    uint32_t indent {0};
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_BLOCK_SCALAR_HEADER_HPP */

// #include <fkYAML/detail/input/position_tracker.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_POSITION_TRACKER_HPP
#define FK_YAML_DETAIL_INPUT_POSITION_TRACKER_HPP

#include <algorithm>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/str_view.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_STR_VIEW_HPP
#define FK_YAML_DETAIL_STR_VIEW_HPP

#include <limits>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Non owning view into constant character sequence.
/// @note
/// This class is a minimal implementation of std::basic_string_view which has been available since C++17
/// but pretty useful and efficient for referencing/investigating character sequences.
/// @warning
/// This class intentionally omits a lot of value checks to improve efficiency. Necessary checks should be
/// made before calling this class' APIs for safety.
/// @tparam CharT Character type
/// @tparam Traits Character traits type which defaults to std::char_traits<CharT>.
template <typename CharT, typename Traits = std::char_traits<CharT>>
class basic_str_view {
    static_assert(!std::is_array<CharT>::value, "CharT must not be an array type.");
    static_assert(
        std::is_trivial<CharT>::value && std::is_standard_layout<CharT>::value,
        "CharT must be a trivial, standard layout type.");
    static_assert(
        std::is_same<CharT, typename Traits::char_type>::value, "CharT & Traits::char_type must be the same type.");

public:
    /// Character traits type.
    using traits_type = Traits;
    /// Character type.
    using value_type = CharT;
    /// Pointer type to a character.
    using pointer = value_type*;
    /// Constant pointer type to a character.
    using const_pointer = const value_type*;
    /// Reference type to a character.
    using reference = value_type&;
    /// Constant reference type to a character.
    using const_reference = const value_type&;
    /// Constant iterator type to a character.
    using const_iterator = const value_type*;
    /// Iterator type to a character.
    /// (Always constant since this class isn't meant to provide any mutating features.)
    using iterator = const_iterator;
    /// Constant reverse iterator type to a character.
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    /// Reverse iterator type to a character.
    /// (Always constant since this class isn't meant to provide any mutating features.)
    using reverse_iterator = const_reverse_iterator;
    /// Size type for character sequence sizes.
    using size_type = std::size_t;
    /// Difference type for distances between characters.
    using difference_type = std::ptrdiff_t;

    /// Invalid position value.
    static constexpr size_type npos = static_cast<size_type>(-1);

    /// Constructs a basic_str_view object.
    constexpr basic_str_view() noexcept = default;

    /// Destroys a basic_str_view object.
    ~basic_str_view() noexcept = default;

    /// @brief Copy constructs a basic_str_view object.
    /// @param _ A basic_str_view object to copy from.
    constexpr basic_str_view(const basic_str_view&) noexcept = default;

    /// @brief Move constructs a basic_str_view object.
    /// @param _ A basic_str_view object to move from.
    constexpr basic_str_view(basic_str_view&&) noexcept = default;

    /// @brief Constructs a basic_str_view object from a pointer to a character sequence.
    /// @note std::char_traits::length() is constexpr from C++17.
    /// @param p_str A pointer to a character sequence. (Must be null-terminated, or an undefined behavior.)
    template <
        typename CharPtrT,
        enable_if_t<
            conjunction<
                negation<std::is_array<CharPtrT>>, std::is_pointer<CharPtrT>,
                disjunction<std::is_same<CharPtrT, value_type*>, std::is_same<CharPtrT, const value_type*>>>::value,
            int> = 0>
    FK_YAML_CXX17_CONSTEXPR basic_str_view(CharPtrT p_str) noexcept
        : m_len(traits_type::length(p_str)),
          mp_str(p_str) {
    }

    /// @brief Constructs a basic_str_view object from a C-style char array.
    /// @note
    /// This constructor assumes the last element is the null character ('\0'). If that's not desirable, consider using
    /// one of the other overloads.
    /// @tparam N The size of a C-style char array.
    /// @param str A C-style char array. (Must be null-terminated)
    template <std::size_t N>
    constexpr basic_str_view(const value_type (&str)[N]) noexcept
        : m_len(N - 1),
          mp_str(&str[0]) {
    }

    /// @brief Construction from a null pointer is forbidden.
    basic_str_view(std::nullptr_t) = delete;

    /// @brief Constructs a basic_str_view object from a pointer to a character sequence and its size.
    /// @param p_str A pointer to a character sequence. (May or may not be null-terminated.)
    /// @param len The length of a character sequence.
    constexpr basic_str_view(const value_type* p_str, size_type len) noexcept
        : m_len(len),
          mp_str(p_str) {
    }

    /// @brief Constructs a basic_str_view object from compatible begin/end iterators
    /// @tparam ItrType Iterator type to a character.
    /// @param first The iterator to the first element of a character sequence.
    /// @param last The iterator to the past-the-end of a character sequence.
    template <
        typename ItrType,
        enable_if_t<
            conjunction<
                is_iterator_of<ItrType, CharT>,
                std::is_base_of<
                    std::random_access_iterator_tag, typename std::iterator_traits<ItrType>::iterator_category>>::value,
            int> = 0>
    basic_str_view(ItrType first, ItrType last) noexcept
        : m_len(last - first),
          mp_str(&*first) {
    }

    /// @brief Constructs a basic_str_view object from a compatible std::basic_string object.
    /// @param str A compatible character sequence container.
    basic_str_view(const std::basic_string<CharT>& str) noexcept
        : m_len(str.length()),
          mp_str(str.data()) {
    }

    /// @brief Copy assignment operator for this basic_str_view class.
    /// @param _ A basic_str_view object to copy from.
    /// @return Reference to this basic_str_view object.
    basic_str_view& operator=(const basic_str_view&) noexcept = default;

    /// @brief Move assignment operator for this basic_str_view class.
    /// @param _ A basic_str_view object to move from.
    /// @return Reference to this basic_str_view object.
    basic_str_view& operator=(basic_str_view&&) noexcept = default;

    /// @brief Get the iterator to the first element. (Always constant)
    /// @return The iterator to the first element.
    const_iterator begin() const noexcept {
        return mp_str;
    }

    /// @brief Get the iterator to the past-the-end element. (Always constant)
    /// @return The iterator to the past-the-end element.
    const_iterator end() const noexcept {
        return mp_str + m_len;
    }

    /// @brief Get the iterator to the first element. (Always constant)
    /// @return The iterator to the first element.
    const_iterator cbegin() const noexcept {
        return mp_str;
    }

    /// @brief Get the iterator to the past-the-end element. (Always constant)
    /// @return The iterator to the past-the-end element.
    const_iterator cend() const noexcept {
        return mp_str + m_len;
    }

    /// @brief Get the iterator to the first element in the reverse order. (Always constant)
    /// @return The iterator to the first element in the reverse order.
    const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    /// @brief Get the iterator to the past-the-end element in the reverse order. (Always constant)
    /// @return The iterator to the past-the-end element in the reverse order.
    const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    /// @brief Get the iterator to the first element in the reverse order. (Always constant)
    /// @return The iterator to the first element in the reverse order.
    const_reverse_iterator crbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    /// @brief Get the iterator to the past-the-end element in the reverse order. (Always constant)
    /// @return The iterator to the past-the-end element in the reverse order.
    const_reverse_iterator crend() const noexcept {
        return const_reverse_iterator(begin());
    }

    /// @brief Get the size of the referenced character sequence.
    /// @return The size of the referenced character sequence.
    size_type size() const noexcept {
        return m_len;
    }

    /// @brief Get the size of the referenced character sequence.
    /// @return The size of the referenced character sequence.
    size_type length() const noexcept {
        return m_len;
    }

    /// @brief Get the maximum number of the character sequence size.
    /// @return The maximum number of the character sequence size.
    constexpr size_type max_size() const noexcept {
        return static_cast<size_type>(std::numeric_limits<difference_type>::max());
    }

    /// @brief Checks if the referenced character sequence is empty.
    /// @return true if empty, false otherwise.
    bool empty() const noexcept {
        return m_len == 0;
    }

    /// @brief Get the element at the given position.
    /// @param pos The position of the target element.
    /// @return The element at the given position.
    const_reference operator[](size_type pos) const noexcept {
        return *(mp_str + pos);
    }

    /// @brief Get the element at the given position with bounds checks.
    /// @warning Throws an fkyaml::out_of_range exception if the position exceeds the character sequence size.
    /// @param pos The position of the target element.
    /// @return The element at the given position.
    const_reference at(size_type pos) const {
        if FK_YAML_UNLIKELY (pos >= m_len) {
            throw fkyaml::out_of_range(static_cast<int>(pos));
        }
        return *(mp_str + pos);
    }

    /// @brief Get the first element.
    /// @return The first element.
    const_reference front() const noexcept {
        return *mp_str;
    }

    /// @brief Get the last element.
    /// @return The last element.
    const_reference back() const {
        return *(mp_str + m_len - 1);
    }

    /// @brief Get the pointer to the raw data of referenced character sequence.
    /// @return The pointer to the raw data of referenced character sequence.
    const_pointer data() const noexcept {
        return mp_str;
    }

    /// @brief Moves the beginning position by `n` elements.
    /// @param n The number of elements by which to move the beginning position.
    void remove_prefix(size_type n) noexcept {
        mp_str += n;
        m_len -= n;
    }

    /// @brief Shrinks the referenced character sequence from the last by `n` elements.
    /// @param n The number of elements by which to shrink the sequence from the last.
    void remove_suffix(size_type n) noexcept {
        m_len -= n;
    }

    /// @brief Swaps data with the given basic_str_view object.
    /// @param other A basic_str_view object to swap data with.
    void swap(basic_str_view& other) noexcept {
        auto tmp = *this;
        *this = other;
        other = tmp;
    }

    /// @brief Copys the referenced character sequence values from `pos` by `n` size.
    /// @warning Throws an fkyaml::out_of_range exception if the given `pos` is bigger than the length.
    /// @param p_str The pointer to a character sequence buffer for output.
    /// @param n The number of elements to write into `p_str`.
    /// @param pos The offset of the beginning position to copy values.
    /// @return The number of elements to be written into `p_str`.
    size_type copy(CharT* p_str, size_type n, size_type pos = 0) const {
        if FK_YAML_UNLIKELY (pos > m_len) {
            throw fkyaml::out_of_range(static_cast<int>(pos));
        }
        const size_type rlen = std::min(n, m_len - pos);
        traits_type::copy(p_str, mp_str + pos, rlen);
        return rlen;
    }

    /// @brief Constructs a sub basic_str_view object from `pos` by `n` size.
    /// @warning Throws an fkyaml::out_of_range exception if the given `pos` is bigger than the length.
    /// @param pos The offset of the beginning position.
    /// @param n The number of elements to the end of a new sub basic_str_view object.
    /// @return A newly created sub basic_str_view object.
    basic_str_view substr(size_type pos = 0, size_type n = npos) const {
        if FK_YAML_UNLIKELY (pos > m_len) {
            throw fkyaml::out_of_range(static_cast<int>(pos));
        }
        const size_type rlen = std::min(n, m_len - pos);
        return basic_str_view(mp_str + pos, rlen);
    }

    /// @brief Compares the referenced character sequence values with the given basic_str_view object.
    /// @param sv The basic_str_view object to compare with.
    /// @return The lexicographical comparison result. The values are same as std::strncmp().
    int compare(basic_str_view sv) const noexcept {
        const size_type rlen = std::min(m_len, sv.m_len);
        int ret = traits_type::compare(mp_str, sv.mp_str, rlen);

        if (ret == 0) {
            using int_limits = std::numeric_limits<int>;
            const difference_type diff =
                m_len > sv.m_len ? m_len - sv.m_len
                                 : static_cast<difference_type>(-1) * static_cast<difference_type>(sv.m_len - m_len);

            if (diff > int_limits::max()) {
                ret = int_limits::max();
            }
            else if (diff < int_limits::min()) {
                ret = int_limits::min();
            }
            else {
                ret = static_cast<int>(diff);
            }
        }

        return ret;
    }

    /// @brief Compares the referenced character sequence values from `pos1` by `n1` characters with `sv`.
    /// @param pos1 The offset of the beginning element.
    /// @param n1 The length of character sequence used for comparison.
    /// @param sv A basic_str_view object to compare with.
    /// @return The lexicographical comparison result. The values are same as std::strncmp().
    int compare(size_type pos1, size_type n1, basic_str_view sv) const {
        return substr(pos1, n1).compare(sv);
    }

    /// @brief Compares the referenced character sequence value from `pos1` by `n1` characters with `sv` from `pos2` by
    /// `n2` characters.
    /// @param pos1 The offset of the beginning element in this character sequence.
    /// @param n1 The length of this character sequence used for comparison.
    /// @param sv A basic_str_view object to compare with.
    /// @param pos2 The offset of the beginning element in `sv`.
    /// @param n2 The length of `sv` used for comparison.
    /// @return The lexicographical comparison result. The values are same as std::strncmp().
    int compare(size_type pos1, size_type n1, basic_str_view sv, size_type pos2, size_type n2) const {
        return substr(pos1, n1).compare(sv.substr(pos2, n2));
    }

    /// @brief Compares the referenced character sequence with `s` character sequence.
    /// @param s The pointer to a character sequence to compare with.
    /// @return The lexicographical comparison result. The values are same as std::strncmp().
    int compare(const CharT* s) const {
        return compare(basic_str_view(s));
    }

    /// @brief Compares the referenced character sequence from `pos1` by `n1` characters with `s` character sequence.
    /// @param pos1 The offset of the beginning element in this character sequence.
    /// @param n1 The length of this character sequence used fo comparison.
    /// @param s The pointer to a character sequence to compare with.
    /// @return The lexicographical comparison result. The values are same as std::strncmp().
    int compare(size_type pos1, size_type n1, const CharT* s) const {
        return substr(pos1, n1).compare(basic_str_view(s));
    }

    /// @brief Compares the referenced character sequence from `pos1` by `n1` characters with `s` character sequence by
    /// `n2` characters.
    /// @param pos1 The offset of the beginning element in this character sequence.
    /// @param n1 The length of this character sequence used fo comparison.
    /// @param s The pointer to a character sequence to compare with.
    /// @param n2 The length of `s` used fo comparison.
    /// @return
    int compare(size_type pos1, size_type n1, const CharT* s, size_type n2) const {
        return substr(pos1, n1).compare(basic_str_view(s, n2));
    }

    /// @brief Checks if this character sequence starts with `sv` characters.
    /// @param sv The character sequence to compare with.
    /// @return true if the character sequence starts with `sv` characters, false otherwise.
    bool starts_with(basic_str_view sv) const {
        return substr(0, sv.size()) == sv;
    }

    /// @brief Checks if this character sequence starts with `c` character.
    /// @param c The character to compare with.
    /// @return true if the character sequence starts with `c` character, false otherwise.
    bool starts_with(CharT c) const noexcept {
        return !empty() && traits_type::eq(front(), c);
    }

    /// @brief Checks if this character sequence starts with `s` characters.
    /// @param s The character sequence to compare with.
    /// @return true if the character sequence starts with `s` characters, false otherwise.
    bool starts_with(const CharT* s) const {
        return starts_with(basic_str_view(s));
    }

    /// @brief Checks if this character sequence ends with `sv` characters.
    /// @param sv The character sequence to compare with.
    /// @return true if the character sequence ends with `sv` characters, false otherwise.
    bool ends_with(basic_str_view sv) const noexcept {
        const size_type size = m_len;
        const size_type sv_size = sv.size();
        return size >= sv_size && traits_type::compare(end() - sv_size, sv.data(), sv_size) == 0;
    }

    /// @brief Checks if this character sequence ends with `c` character.
    /// @param c The character to compare with.
    /// @return true if the character sequence ends with `c` character, false otherwise.
    bool ends_with(CharT c) const noexcept {
        return !empty() && traits_type::eq(back(), c);
    }

    /// @brief Checks if this character sequence ends with `s` characters.
    /// @param s The character sequence to compare with.
    /// @return true if the character sequence ends with `s` characters, false otherwise.
    bool ends_with(const CharT* s) const noexcept {
        return ends_with(basic_str_view(s));
    }

    /// @brief Checks if this character sequence contains `sv` characters.
    /// @param sv The character sequence to compare with.
    /// @return true if the character sequence contains `sv` characters, false otherwise.
    bool contains(basic_str_view sv) const noexcept {
        return find(sv) != npos;
    }

    /// @brief Checks if this character sequence contains `c` character.
    /// @param c The character to compare with.
    /// @return true if the character sequence contains `c` character, false otherwise.
    bool contains(CharT c) const noexcept {
        return find(c) != npos;
    }

    /// @brief Checks if this character sequence contains `s` characters.
    /// @param s The character sequence to compare with.
    /// @return true if the character sequence contains `s` characters, false otherwise.
    bool contains(const CharT* s) const noexcept {
        return find(s) != npos;
    }

    /// @brief Finds the beginning position of `sv` characters in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `sv` characters, `npos` otherwise.
    size_type find(basic_str_view sv, size_type pos = 0) const noexcept {
        return find(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Finds the beginning position of `c` character in this referenced character sequence.
    /// @param sv The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `c` character, `npos` otherwise.
    size_type find(CharT c, size_type pos = 0) const noexcept {
        size_type ret = npos;

        if FK_YAML_LIKELY (pos < m_len) {
            const size_type n = m_len - pos;
            const CharT* p_found = traits_type::find(mp_str + pos, n, c);
            if (p_found) {
                ret = p_found - mp_str;
            }
        }

        return ret;
    }

    /// @brief Finds the beginning position of `s` character sequence by `n` characters in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find(const CharT* s, size_type pos, size_type n) const noexcept {
        if FK_YAML_UNLIKELY (n == 0) {
            return pos <= m_len ? pos : npos;
        }

        if FK_YAML_UNLIKELY (pos >= m_len) {
            return npos;
        }

        CharT s0 = s[0];
        const CharT* p_first = mp_str + pos;
        const CharT* p_last = mp_str + m_len;
        size_type len = m_len - pos;

        while (len >= n) {
            // find the first occurrence of s0
            p_first = traits_type::find(p_first, len - n + 1, s0);
            if (!p_first) {
                return npos;
            }

            // compare the full strings from the first occurrence of s0
            if (traits_type::compare(p_first, s, n) == 0) {
                return p_first - mp_str;
            }

            len = p_last - (++p_first);
        }

        return npos;
    }

    /// @brief Finds the beginning position of `s` character sequence in this referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find(const CharT* s, size_type pos = 0) const noexcept {
        return find(basic_str_view(s), pos);
    }

    /// @brief Retrospectively finds the beginning position of `sv` characters in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `sv` characters, `npos` otherwise.
    size_type rfind(basic_str_view sv, size_type pos = npos) const noexcept {
        return rfind(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Retrospectively finds the beginning position of `c` character in this referenced character sequence.
    /// @param sv The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `c` character, `npos` otherwise.
    size_type rfind(CharT c, size_type pos = npos) const noexcept {
        if FK_YAML_UNLIKELY (m_len == 0) {
            return npos;
        }

        const size_type idx = std::min(m_len - 1, pos);

        for (size_type i = 0; i <= idx; i++) {
            if (traits_type::eq(mp_str[idx - i], c)) {
                return idx - i;
            }
        }

        return npos;
    }

    /// @brief Retrospectively finds the beginning position of `s` character sequence by `n` characters in this
    /// referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type rfind(const CharT* s, size_type pos, size_type n) const noexcept {
        if FK_YAML_LIKELY (n <= m_len) {
            pos = std::min(m_len - n, pos) + 1;

            do {
                if (traits_type::compare(mp_str + --pos, s, n) == 0) {
                    return pos;
                }
            } while (pos > 0);
        }

        return npos;
    }

    /// @brief Retrospectively finds the beginning position of `s` character sequence in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type rfind(const CharT* s, size_type pos = npos) const noexcept {
        return rfind(basic_str_view(s), pos);
    }

    /// @brief Finds the first occurrence of `sv` character sequence in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `sv` characters, `npos` otherwise.
    size_type find_first_of(basic_str_view sv, size_type pos = 0) const noexcept {
        return find_first_of(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Finds the first occurrence of `c` character in this referenced character sequence.
    /// @param c The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `c` character, `npos` otherwise.
    size_type find_first_of(CharT c, size_type pos = 0) const noexcept {
        return find(c, pos);
    }

    /// @brief Finds the first occurrence of `s` character sequence by `n` characters in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find_first_of(const CharT* s, size_type pos, size_type n) const noexcept {
        if FK_YAML_UNLIKELY (n == 0) {
            return npos;
        }

        for (size_type idx = pos; idx < m_len; ++idx) {
            const CharT* p_found = traits_type::find(s, n, mp_str[idx]);
            if (p_found) {
                return idx;
            }
        }

        return npos;
    }

    /// @brief Finds the first occurrence of `s` character sequence in this referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find_first_of(const CharT* s, size_type pos = 0) const noexcept {
        return find_first_of(basic_str_view(s), pos);
    }

    /// @brief Finds the last occurrence of `sv` character sequence in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `sv` characters, `npos` otherwise.
    size_type find_last_of(basic_str_view sv, size_type pos = npos) const noexcept {
        return find_last_of(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Finds the last occurrence of `c` character in this referenced character sequence.
    /// @param c The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `c` character, `npos` otherwise.
    size_type find_last_of(CharT c, size_type pos = npos) const noexcept {
        return rfind(c, pos);
    }

    /// @brief Finds the last occurrence of `s` character sequence by `n` characters in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find_last_of(const CharT* s, size_type pos, size_type n) const noexcept {
        if FK_YAML_LIKELY (n <= m_len) {
            pos = std::min(m_len - n - 1, pos);

            do {
                const CharT* p_found = traits_type::find(s, n, mp_str[pos]);
                if (p_found) {
                    return pos;
                }
            } while (pos-- != 0);
        }

        return npos;
    }

    /// @brief Finds the last occurrence of `s` character sequence in this referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of `s` characters, `npos` otherwise.
    size_type find_last_of(const CharT* s, size_type pos = npos) const noexcept {
        return find_last_of(basic_str_view(s), pos);
    }

    /// @brief Finds the first absence of `sv` character sequence in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `sv` characters, `npos` otherwise.
    size_type find_first_not_of(basic_str_view sv, size_type pos = 0) const noexcept {
        return find_first_not_of(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Finds the first absence of `c` character in this referenced character sequence.
    /// @param c The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `c` character, `npos` otherwise.
    size_type find_first_not_of(CharT c, size_type pos = 0) const noexcept {
        for (; pos < m_len; ++pos) {
            if (!traits_type::eq(mp_str[pos], c)) {
                return pos;
            }
        }

        return npos;
    }

    /// @brief Finds the first absence of `s` character sequence by `n` characters in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of non `s` characters, `npos` otherwise.
    size_type find_first_not_of(const CharT* s, size_type pos, size_type n) const noexcept {
        for (; pos < m_len; ++pos) {
            const CharT* p_found = traits_type::find(s, n, mp_str[pos]);
            if (!p_found) {
                return pos;
            }
        }

        return npos;
    }

    /// @brief Finds the first absence of `s` character sequence in this referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `s` characters, `npos` otherwise.
    size_type find_first_not_of(const CharT* s, size_type pos = 0) const noexcept {
        return find_first_not_of(basic_str_view(s), pos);
    }

    /// @brief Finds the last absence of `sv` character sequence in this referenced character sequence.
    /// @param sv The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `sv` characters, `npos` otherwise.
    size_type find_last_not_of(basic_str_view sv, size_type pos = npos) const noexcept {
        return find_last_not_of(sv.mp_str, pos, sv.m_len);
    }

    /// @brief Finds the last absence of `c` character in this referenced character sequence.
    /// @param c The character to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `c` character, `npos` otherwise.
    size_type find_last_not_of(CharT c, size_type pos = npos) const noexcept {
        if FK_YAML_LIKELY (m_len > 0) {
            pos = std::min(m_len, pos);

            do {
                if (!traits_type::eq(mp_str[--pos], c)) {
                    return pos;
                }
            } while (pos > 0);
        }

        return npos;
    }

    /// @brief Finds the last absence of `s` character sequence by `n` characters in this referenced character
    /// sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @param n The length of `s` character sequence used for comparison.
    /// @return The beginning position of non `s` characters, `npos` otherwise.
    size_type find_last_not_of(const CharT* s, size_type pos, size_type n) const noexcept {
        if FK_YAML_UNLIKELY (n <= m_len) {
            pos = std::min(m_len - n, pos) + 1;

            do {
                const CharT* p_found = traits_type::find(s, n, mp_str[--pos]);
                if (!p_found) {
                    return pos;
                }
            } while (pos > 0);
        }

        return npos;
    }

    /// @brief Finds the last absence of `s` character sequence in this referenced character sequence.
    /// @param s The character sequence to compare with.
    /// @param pos The offset of the search beginning position in this referenced character sequence.
    /// @return The beginning position of non `s` characters, `npos` otherwise.
    size_type find_last_not_of(const CharT* s, size_type pos = npos) const noexcept {
        return find_last_not_of(basic_str_view(s), pos);
    }

private:
    size_type m_len {0};
    const value_type* mp_str {nullptr};
};

// Prior to C++17, a static constexpr class member needs an out-of-class definition.
#ifndef FK_YAML_HAS_CXX_17

template <typename CharT, typename Traits>
constexpr typename basic_str_view<CharT, Traits>::size_type basic_str_view<CharT, Traits>::npos;

#endif // !defined(FK_YAML_HAS_CXX_17)

/// @brief An equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if the two objects are the same, false otherwise.
template <typename CharT, typename Traits>
inline bool operator==(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    // Comparing the lengths first will omit unnecessary value comparison in compare().
    return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
}

/// @brief An equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_string object to compare with.
/// @return true if the two objects are the same, false otherwise.
template <typename CharT, typename Traits>
inline bool operator==(basic_str_view<CharT, Traits> lhs, const std::basic_string<CharT, Traits>& rhs) noexcept {
    return lhs == basic_str_view<CharT, Traits>(rhs);
}

/// @brief An equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_string object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if the two objects are the same, false otherwise.
template <typename CharT, typename Traits>
inline bool operator==(const std::basic_string<CharT, Traits>& lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return basic_str_view<CharT, Traits>(lhs) == rhs;
}

/// @brief An equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @tparam N The length of the character array.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A character array to compare with.
/// @return true if the two objects are the same, false otherwise.
template <typename CharT, typename Traits, std::size_t N>
inline bool operator==(basic_str_view<CharT, Traits> lhs, const CharT (&rhs)[N]) noexcept {
    // assume `rhs` is null terminated
    return lhs == basic_str_view<CharT, Traits>(rhs);
}

/// @brief An equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @tparam N The length of the character array.
/// @param rhs A character array for comparison.
/// @param lhs A basic_str_view object to compare with.
/// @return true if the two objects are the same, false otherwise.
template <typename CharT, typename Traits, std::size_t N>
inline bool operator==(const CharT (&lhs)[N], basic_str_view<CharT, Traits> rhs) noexcept {
    // assume `lhs` is null terminated
    return basic_str_view<CharT, Traits>(lhs) == rhs;
}

/// @brief An not-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if the two objects are different, false otherwise.
template <typename CharT, typename Traits>
inline bool operator!=(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return !(lhs == rhs);
}

/// @brief An not-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_string object to compare with.
/// @return true if the two objects are different, false otherwise.
template <typename CharT, typename Traits>
inline bool operator!=(basic_str_view<CharT, Traits> lhs, const std::basic_string<CharT, Traits>& rhs) noexcept {
    return !(lhs == basic_str_view<CharT, Traits>(rhs));
}

/// @brief An not-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_string object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if the two objects are different, false otherwise.
template <typename CharT, typename Traits>
inline bool operator!=(const std::basic_string<CharT, Traits>& lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return !(basic_str_view<CharT, Traits>(lhs) == rhs);
}

/// @brief An not-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @tparam N The length of the character array.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A character array to compare with.
/// @return true if the two objects are different, false otherwise.
template <typename CharT, typename Traits, std::size_t N>
inline bool operator!=(basic_str_view<CharT, Traits> lhs, const CharT (&rhs)[N]) noexcept {
    // assume `rhs` is null terminated.
    return !(lhs == basic_str_view<CharT, Traits>(rhs, N - 1));
}

/// @brief An not-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @tparam N The length of the character array.
/// @param rhs A character array for comparison.
/// @param lhs A basic_str_view object to compare with.
/// @return true if the two objects are different, false otherwise.
template <typename CharT, typename Traits, std::size_t N>
inline bool operator!=(const CharT (&lhs)[N], basic_str_view<CharT, Traits> rhs) noexcept {
    // assume `lhs` is null terminate
    return !(basic_str_view<CharT, Traits>(lhs, N - 1) == rhs);
}

/// @brief An less-than operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if `lhs` is less than `rhs`, false otherwise.
template <typename CharT, typename Traits>
inline bool operator<(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return lhs.compare(rhs) < 0;
}

/// @brief An less-than-or-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if `lhs` is less than or equal to `rhs`, false otherwise.
template <typename CharT, typename Traits>
inline bool operator<=(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return lhs.compare(rhs) <= 0;
}

/// @brief An greater-than operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if `lhs` is greater than `rhs`, false otherwise.
template <typename CharT, typename Traits>
inline bool operator>(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return lhs.compare(rhs) > 0;
}

/// @brief An greater-than-or-equal-to operator of the basic_str_view class.
/// @tparam CharT Character type
/// @tparam Traits Character traits type.
/// @param lhs A basic_str_view object for comparison.
/// @param rhs A basic_str_view object to compare with.
/// @return true if `lhs` is greater than or equal to `rhs`, false otherwise.
template <typename CharT, typename Traits>
inline bool operator>=(basic_str_view<CharT, Traits> lhs, basic_str_view<CharT, Traits> rhs) noexcept {
    return lhs.compare(rhs) >= 0;
}

/// @brief Insertion operator of the basic_str_view class.
/// @tparam CharT Character type.
/// @tparam Traits Character traits type.
/// @param os An output stream object.
/// @param sv A basic_str_view object.
/// @return Reference to the output stream object `os`.
template <typename CharT, typename Traits>
inline std::basic_ostream<CharT, Traits>& operator<<(
    std::basic_ostream<CharT, Traits>& os, basic_str_view<CharT, Traits> sv) {
    return os.write(sv.data(), static_cast<std::streamsize>(sv.size()));
}

/// @brief view into `char` sequence.
using str_view = basic_str_view<char>;

#if FK_YAML_HAS_CHAR8_T
/// @brief view into `char8_t` sequence.
using u8str_view = basic_str_view<char8_t>;
#endif

/// @brief view into `char16_t` sequence.
using u16str_view = basic_str_view<char16_t>;

/// @brief view into `char32_t` sequence.
using u32str_view = basic_str_view<char32_t>;

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_STR_VIEW_HPP */


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A position tracker of the target buffer.
class position_tracker {
public:
    void set_target_buffer(str_view buffer) noexcept {
        m_begin = m_last = buffer.begin();
        m_end = buffer.end();
    }

    /// @brief Update the set of the current position information.
    /// @note This function doesn't support cases where cur_pos has moved backward from the last call.
    /// @param cur_pos The iterator to the current element of the buffer.
    void update_position(const char* p_current) {
        const auto diff = static_cast<uint32_t>(p_current - m_last);
        if (diff == 0) {
            return;
        }

        m_cur_pos += diff;
        const uint32_t prev_lines_read = m_lines_read;
        m_lines_read += static_cast<uint32_t>(std::count(m_last, p_current, '\n'));
        m_last = p_current;

        if (prev_lines_read == m_lines_read) {
            m_cur_pos_in_line += diff;
            return;
        }

        uint32_t count = 0;
        const char* p_begin = m_begin;
        while (--p_current != p_begin) {
            if (*p_current == '\n') {
                break;
            }
            count++;
        }
        m_cur_pos_in_line = count;
    }

    uint32_t get_cur_pos() const noexcept {
        return m_cur_pos;
    }

    /// @brief Get the current position in the current line.
    /// @return uint32_t The current position in the current line.
    uint32_t get_cur_pos_in_line() const noexcept {
        return m_cur_pos_in_line;
    }

    /// @brief Get the number of lines which have already been read.
    /// @return uint32_t The number of lines which have already been read.
    uint32_t get_lines_read() const noexcept {
        return m_lines_read;
    }

private:
    /// The iterator to the beginning element in the target buffer.
    const char* m_begin {};
    /// The iterator to the past-the-end element in the target buffer.
    const char* m_end {};
    /// The iterator to the last updated element in the target buffer.
    const char* m_last {};
    /// The current position from the beginning of an input buffer.
    uint32_t m_cur_pos {0};
    /// The current position in the current line.
    uint32_t m_cur_pos_in_line {0};
    /// The number of lines which have already been read.
    uint32_t m_lines_read {0};
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_POSITION_TRACKER_HPP */

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/str_view.hpp>

// #include <fkYAML/detail/types/lexical_token_t.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_TYPES_LEXICAL_TOKEN_T_HPP
#define FK_YAML_DETAIL_TYPES_LEXICAL_TOKEN_T_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of lexical token types.
enum class lexical_token_t : std::uint8_t {
    END_OF_BUFFER,         //!< the end of input buffer.
    EXPLICIT_KEY_PREFIX,   //!< the character for explicit mapping key prefix `?`.
    KEY_SEPARATOR,         //!< the key separator `:`
    VALUE_SEPARATOR,       //!< the value separator `,`
    ANCHOR_PREFIX,         //!< the character for anchor prefix `&`
    ALIAS_PREFIX,          //!< the character for alias prefix `*`
    YAML_VER_DIRECTIVE,    //!< a YAML version directive found. use get_yaml_version() to get a value.
    TAG_DIRECTIVE,         //!< a TAG directive found. use GetTagInfo() to get the tag information.
    TAG_PREFIX,            //!< the character for tag prefix `!`
    INVALID_DIRECTIVE,     //!< an invalid directive found. do not try to get the value.
    SEQUENCE_BLOCK_PREFIX, //!< the character for sequence block prefix `- `
    SEQUENCE_FLOW_BEGIN,   //!< the character for sequence flow begin `[`
    SEQUENCE_FLOW_END,     //!< the character for sequence flow end `]`
    MAPPING_FLOW_BEGIN,    //!< the character for mapping begin `{`
    MAPPING_FLOW_END,      //!< the character for mapping end `}`
    PLAIN_SCALAR,          //!< plain (unquoted) scalars
    SINGLE_QUOTED_SCALAR,  //!< single-quoted scalars
    DOUBLE_QUOTED_SCALAR,  //!< double-quoted scalars
    BLOCK_LITERAL_SCALAR,  //!< block literal style scalars
    BLOCK_FOLDED_SCALAR,   //!< block folded style scalars
    END_OF_DIRECTIVES,     //!< the end of declaration of directives specified by `---`.
    END_OF_DOCUMENT,       //!< the end of a YAML document specified by `...`.
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_TYPES_LEXICAL_TOKEN_T_HPP */

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Lexical token information
struct lexical_token {
    lexical_token() = default;

    lexical_token(lexical_token_t t, str_view s) noexcept
        : type(t),
          str(s) {
    }

    lexical_token(lexical_token_t t) noexcept
        : type(t) {
    }

    lexical_token(const lexical_token&) = default;
    lexical_token& operator=(const lexical_token&) = default;
    lexical_token(lexical_token&&) = default;
    lexical_token& operator=(lexical_token&&) = default;
    ~lexical_token() = default;

    /// Lexical token type.
    lexical_token_t type {lexical_token_t::END_OF_BUFFER};
    /// Lexical token contents.
    str_view str;
};

/// @brief A class which lexically analyzes YAML formatted inputs.
class lexical_analyzer {
    // whether the current context is flow(1) or block(0)
    static constexpr uint32_t flow_context_bit = 1u << 0u;
    // whether the current document part is directive(1) or content(0)
    static constexpr uint32_t document_directive_bit = 1u << 1u;

public:
    /// @brief Construct a new lexical_analyzer object.
    /// @param input_buffer An input buffer.
    explicit lexical_analyzer(str_view input_buffer) noexcept
        : m_begin_itr(input_buffer.begin()),
          m_cur_itr(input_buffer.begin()),
          m_end_itr(input_buffer.end()) {
        m_pos_tracker.set_target_buffer(input_buffer);
    }

    /// @brief Get the next lexical token by scanning the left of the input buffer.
    /// @return lexical_token The next lexical token.
    lexical_token get_next_token() {
        skip_white_spaces_and_newline_codes();

        m_token_begin_itr = m_cur_itr;
        m_pos_tracker.update_position(m_cur_itr);
        m_last_token_begin_pos = m_pos_tracker.get_cur_pos_in_line();
        m_last_token_begin_line = m_pos_tracker.get_lines_read();

        if (m_cur_itr == m_end_itr) {
            return {lexical_token_t::END_OF_BUFFER};
        }

        switch (*m_cur_itr) {
        case '?':
            if (++m_cur_itr == m_end_itr) {
                return {lexical_token_t::PLAIN_SCALAR, {m_token_begin_itr, 1}};
            }

            if (*m_cur_itr == ' ') {
                return {lexical_token_t::EXPLICIT_KEY_PREFIX};
            }
            break;
        case ':': // key separator
            if (++m_cur_itr == m_end_itr) {
                return {lexical_token_t::KEY_SEPARATOR};
            }

            switch (*m_cur_itr) {
            case ' ':
            case '\t':
            case '\n':
                return {lexical_token_t::KEY_SEPARATOR};
            default:
                if ((m_state & flow_context_bit) == 0) {
                    // in a block context
                    break;
                }

                switch (*m_cur_itr) {
                case ',':
                case '[':
                case ']':
                case '{':
                case '}':
                    // Flow indicators are not "safe" to be followed in a flow context.
                    // See https://yaml.org/spec/1.2.2/#733-plain-style for more details.
                    return {lexical_token_t::KEY_SEPARATOR};
                default:
                    // At least '{' or '[' must precedes this token.
                    FK_YAML_ASSERT(m_token_begin_itr != m_begin_itr);

                    // if a key inside a flow mapping is JSON-like (surrounded by indicators, see below), YAML allows
                    // the following value to be specified adjacent to the ":" mapping value indicator.
                    // ```yaml
                    // # the following flow mapping entries are all valid.
                    // {
                    //   "foo":true,
                    //   'bar':false,          # 'bar' is actually not JSON but allowed in YAML
                    //                         # since its surrounded by the single quotes.
                    //   {[1,2,3]:null}:"baz"
                    // }
                    // ```
                    switch (*(m_token_begin_itr - 1)) {
                    case '\'':
                    case '\"':
                    case ']':
                    case '}':
                        return {lexical_token_t::KEY_SEPARATOR};
                    default:
                        break;
                    }
                    break;
                }
                break;
            }
            break;
        case ',': // value separator
            ++m_cur_itr;
            return {lexical_token_t::VALUE_SEPARATOR};
        case '&': // anchor prefix
            return {lexical_token_t::ANCHOR_PREFIX, extract_anchor_name()};
        case '*': // alias prefix
            return {lexical_token_t::ALIAS_PREFIX, extract_anchor_name()};
        case '!': // tag prefix
            return {lexical_token_t::TAG_PREFIX, extract_tag_name()};
        case '#': // comment prefix
            scan_comment();
            return get_next_token();
        case '%': // directive prefix
            if (m_state & document_directive_bit) {
                return {scan_directive()};
            }
            // The '%' character can be safely used as the first character in document contents.
            // See https://yaml.org/spec/1.2.2/#912-document-markers for more details.
            break;
        case '-': {
            switch (*(m_cur_itr + 1)) {
            case ' ':
            case '\t':
            case '\n':
                // Move a cursor to the beginning of the next token.
                m_cur_itr += 2;
                return {lexical_token_t::SEQUENCE_BLOCK_PREFIX};
            default:
                break;
            }

            if (m_pos_tracker.get_cur_pos_in_line() == 0) {
                if ((m_end_itr - m_cur_itr) > 2) {
                    const bool is_dir_end = std::equal(m_token_begin_itr, m_cur_itr + 3, "---");
                    if (is_dir_end) {
                        m_cur_itr += 3;
                        return {lexical_token_t::END_OF_DIRECTIVES};
                    }
                }
            }

            break;
        }
        case '[': // sequence flow begin
            ++m_cur_itr;
            return {lexical_token_t::SEQUENCE_FLOW_BEGIN};
        case ']': // sequence flow end
            ++m_cur_itr;
            return {lexical_token_t::SEQUENCE_FLOW_END};
        case '{': // mapping flow begin
            ++m_cur_itr;
            return {lexical_token_t::MAPPING_FLOW_BEGIN};
        case '}': // mapping flow end
            ++m_cur_itr;
            return {lexical_token_t::MAPPING_FLOW_END};
        case '@':
            emit_error("Any token cannot start with at(@). It is a reserved indicator for YAML.");
        case '`':
            emit_error("Any token cannot start with grave accent(`). It is a reserved indicator for YAML.");
        case '\"':
            ++m_token_begin_itr;
            return {lexical_token_t::DOUBLE_QUOTED_SCALAR, determine_double_quoted_scalar_range()};
        case '\'':
            ++m_token_begin_itr;
            return {lexical_token_t::SINGLE_QUOTED_SCALAR, determine_single_quoted_scalar_range()};
        case '.': {
            if (m_pos_tracker.get_cur_pos_in_line() == 0) {
                const auto rem_size = m_end_itr - m_cur_itr;
                if FK_YAML_LIKELY (rem_size > 2) {
                    const bool is_doc_end = std::equal(m_cur_itr, m_cur_itr + 3, "...");
                    if (is_doc_end) {
                        if (rem_size > 3) {
                            switch (*(m_cur_itr + 3)) {
                            case ' ':
                            case '\t':
                            case '\n':
                                m_cur_itr += 4;
                                break;
                            default:
                                // See https://yaml.org/spec/1.2.2/#912-document-markers for more details.
                                emit_error("The document end marker \"...\" must not be followed by non-ws char.");
                            }
                        }
                        else {
                            m_cur_itr += 3;
                        }
                        return {lexical_token_t::END_OF_DOCUMENT};
                    }
                }
            }
            break;
        }
        case '|':
        case '>': {
            const str_view sv {m_token_begin_itr, m_end_itr};
            const std::size_t header_end_pos = sv.find('\n');
            FK_YAML_ASSERT(header_end_pos != str_view::npos);
            const uint32_t base_indent = get_current_indent_level(&sv[header_end_pos]);

            const lexical_token_t type = *m_token_begin_itr == '|' ? lexical_token_t::BLOCK_LITERAL_SCALAR
                                                                   : lexical_token_t::BLOCK_FOLDED_SCALAR;
            const str_view header_line = sv.substr(1, header_end_pos - 1);
            m_block_scalar_header = convert_to_block_scalar_header(header_line);

            m_token_begin_itr = sv.begin() + (header_end_pos + 1);

            return {
                type,
                determine_block_scalar_content_range(
                    base_indent, m_block_scalar_header.indent, m_block_scalar_header.indent)};
        }
        default:
            break;
        }

        return {lexical_token_t::PLAIN_SCALAR, determine_plain_scalar_range()};
    }

    /// @brief Get the beginning position of a last token.
    /// @return uint32_t The beginning position of a last token.
    uint32_t get_last_token_begin_pos() const noexcept {
        return m_last_token_begin_pos;
    }

    /// @brief Get the number of lines already processed.
    /// @return uint32_t The number of lines already processed.
    uint32_t get_lines_processed() const noexcept {
        return m_last_token_begin_line;
    }

    /// @brief Get the YAML version specification.
    /// @return str_view A YAML version specification.
    str_view get_yaml_version() const noexcept {
        return m_yaml_version;
    }

    /// @brief Get the YAML tag handle defined in the TAG directive.
    /// @return str_view A tag handle.
    str_view get_tag_handle() const noexcept {
        return m_tag_handle;
    }

    /// @brief Get the YAML tag prefix defined in the TAG directive.
    /// @return str_view A tag prefix.
    str_view get_tag_prefix() const noexcept {
        return m_tag_prefix;
    }

    /// @brief Get block scalar header information.
    /// @return block_scalar_header Block scalar header information.
    block_scalar_header get_block_scalar_header() const noexcept {
        return m_block_scalar_header;
    }

    /// @brief Toggles the context state between flow and block.
    /// @param is_flow_context true: flow context, false: block context
    void set_context_state(bool is_flow_context) noexcept {
        m_state &= ~flow_context_bit;
        if (is_flow_context) {
            m_state |= flow_context_bit;
        }
    }

    /// @brief Toggles the document state between directive and content.
    /// @param is_directive true: directive, false: content
    void set_document_state(bool is_directive) noexcept {
        m_state &= ~document_directive_bit;
        if (is_directive) {
            m_state |= document_directive_bit;
        }
    }

private:
    uint32_t get_current_indent_level(const char* p_line_end) {
        // get the beginning position of the current line.
        std::size_t line_begin_pos = str_view(m_begin_itr, p_line_end - 1).find_last_of('\n');
        if (line_begin_pos == str_view::npos) {
            line_begin_pos = 0;
        }
        else {
            ++line_begin_pos;
        }
        const char* p_line_begin = m_begin_itr + line_begin_pos;
        const char* cur_itr = p_line_begin;

        // get the indentation of the current line.
        uint32_t indent = 0;
        bool indent_found = false;
        // 0: none, 1: block seq item, 2: explicit map key, 3: explicit map value
        uint32_t context = 0;
        while (cur_itr != p_line_end && !indent_found) {
            switch (*cur_itr) {
            case ' ':
                ++indent;
                ++cur_itr;
                break;
            case '-':
                switch (*(cur_itr + 1)) {
                case ' ':
                case '\t':
                    indent += 2;
                    cur_itr += 2;
                    context = 1;
                    break;
                default:
                    indent_found = true;
                    break;
                }
                break;
            case '?':
                if (*(cur_itr + 1) == ' ') {
                    indent += 2;
                    cur_itr += 2;
                    context = 2;
                    break;
                }

                indent_found = true;
                break;
            case ':':
                switch (*(cur_itr + 1)) {
                case ' ':
                case '\t':
                    indent += 2;
                    cur_itr += 2;
                    context = 3;
                    break;
                default:
                    indent_found = true;
                    break;
                }
                break;
            default:
                indent_found = true;
                break;
            }
        }

        // If "- ", "? " and/or ": " occur in the first line of this plain scalar content.
        if (context > 0) {
            // Check if the first line contains the key separator ": ".
            // If so, the indent value remains the current one.
            // Otherwise, the indent value is changed based on the last ocurrence of the above 3.
            // In any case, multiline plain scalar content must be indented more than the indent value.
            const str_view line_content_part {p_line_begin + indent, p_line_end};
            std::size_t key_sep_pos = line_content_part.find(": ");
            if (key_sep_pos == str_view::npos) {
                key_sep_pos = line_content_part.find(":\t");
            }

            if (key_sep_pos == str_view::npos) {
                constexpr char targets[] = "-?:";
                FK_YAML_ASSERT(context - 1 < sizeof(targets));
                // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                const char target_char = targets[context - 1];

                // Find the position of the last ocuurence of "- ", "? " or ": ".
                const str_view line_indent_part {p_line_begin, indent};
                const std::size_t block_seq_item_begin_pos = line_indent_part.find_last_of(target_char);
                FK_YAML_ASSERT(block_seq_item_begin_pos != str_view::npos);
                indent = static_cast<uint32_t>(block_seq_item_begin_pos);
            }
        }

        return indent;
    }

    /// @brief Skip until a newline code or a null character is found.
    void scan_comment() {
        FK_YAML_ASSERT(*m_cur_itr == '#');
        if FK_YAML_LIKELY (m_cur_itr != m_begin_itr) {
            switch (*(m_cur_itr - 1)) {
            case ' ':
            case '\t':
            case '\n':
                break;
            default:
                emit_error("Comment must not begin right after non-break characters");
            }
        }
        skip_until_line_end();
    }

    /// @brief Scan directives starting with the prefix '%'
    /// @note Currently, only %YAML directive is supported. If not, returns invalid or throws an exception.
    /// @return lexical_token_t The lexical token type for directives.
    lexical_token_t scan_directive() {
        FK_YAML_ASSERT(*m_cur_itr == '%');

        m_token_begin_itr = ++m_cur_itr;

        bool ends_loop = false;
        while (!ends_loop && m_cur_itr != m_end_itr) {
            switch (*m_cur_itr) {
            case ' ':
            case '\t':
                ends_loop = true;
                break;
            case '\n':
                skip_until_line_end();
                return lexical_token_t::INVALID_DIRECTIVE;
            default:
                ++m_cur_itr;
                break;
            }
        }

        const str_view dir_name(m_token_begin_itr, m_cur_itr);

        if (dir_name == "TAG") {
            if FK_YAML_UNLIKELY (!ends_loop) {
                emit_error("There must be at least one white space between \"%TAG\" and tag info.");
            }
            skip_white_spaces();
            return scan_tag_directive();
        }

        if (dir_name == "YAML") {
            if FK_YAML_UNLIKELY (!ends_loop) {
                emit_error("There must be at least one white space between \"%YAML\" and version.");
            }
            skip_white_spaces();
            return scan_yaml_version_directive();
        }

        skip_until_line_end();
        return lexical_token_t::INVALID_DIRECTIVE;
    }

    /// @brief Scan a YAML tag directive.
    /// @return lexical_token_t The lexical token type for YAML tag directives.
    lexical_token_t scan_tag_directive() {
        m_token_begin_itr = m_cur_itr;

        //
        // extract a tag handle
        //

        if FK_YAML_UNLIKELY (*m_cur_itr != '!') {
            emit_error("Tag handle must start with \'!\'.");
        }

        if FK_YAML_UNLIKELY (++m_cur_itr == m_end_itr) {
            emit_error("invalid TAG directive is found.");
        }

        switch (*m_cur_itr) {
        case ' ':
        case '\t':
            // primary handle (!)
            break;
        case '!':
            if FK_YAML_UNLIKELY (++m_cur_itr == m_end_itr) {
                emit_error("invalid TAG directive is found.");
            }
            if FK_YAML_UNLIKELY (*m_cur_itr != ' ' && *m_cur_itr != '\t') {
                emit_error("invalid tag handle is found.");
            }
            break;
        default: {
            bool ends_loop = false;
            do {
                switch (*m_cur_itr) {
                case ' ':
                case '\t':
                    emit_error("invalid tag handle is found.");
                case '!': {
                    if (m_cur_itr + 1 == m_end_itr) {
                        ends_loop = true;
                        break;
                    }
                    const char next = *(m_cur_itr + 1);
                    if FK_YAML_UNLIKELY (next != ' ' && next != '\t') {
                        emit_error("invalid tag handle is found.");
                    }
                    ends_loop = true;
                    break;
                }
                case '-':
                    break;
                default:
                    if FK_YAML_UNLIKELY (!isalnum(*m_cur_itr)) {
                        // See https://yaml.org/spec/1.2.2/#rule-c-named-tag-handle for more details.
                        emit_error("named handle can contain only numbers(0-9), alphabets(A-Z,a-z) and hyphens(-).");
                    }
                    break;
                }

                if FK_YAML_UNLIKELY (++m_cur_itr == m_end_itr) {
                    emit_error("invalid TAG directive is found.");
                }
            } while (!ends_loop);
            break;
        }
        }

        m_tag_handle = str_view {m_token_begin_itr, m_cur_itr};

        skip_white_spaces();

        //
        // extract a tag prefix.
        //

        m_token_begin_itr = m_cur_itr;
        const char* p_tag_prefix_begin = m_cur_itr;
        switch (*m_cur_itr) {
        // a tag prefix must not start with flow indicators to avoid ambiguity.
        // See https://yaml.org/spec/1.2.2/#rule-ns-global-tag-prefix for more details.
        case ',':
        case '[':
        case ']':
        case '{':
        case '}':
            emit_error("tag prefix must not start with flow indicators (\',\', [], {}).");
        default:
            break;
        }

        // extract the rest of a tag prefix.
        bool ends_loop = false;
        do {
            switch (*m_cur_itr) {
            case ' ':
            case '\t':
            case '\n':
                ends_loop = true;
                break;
            default:
                break;
            }
        } while (!ends_loop && ++m_cur_itr != m_end_itr);

        const bool is_valid = uri_encoding::validate(p_tag_prefix_begin, m_cur_itr);
        if FK_YAML_UNLIKELY (!is_valid) {
            emit_error("invalid URI character is found in a tag prefix.");
        }

        m_tag_prefix = str_view {p_tag_prefix_begin, m_cur_itr};

        return lexical_token_t::TAG_DIRECTIVE;
    }

    /// @brief Scan a YAML version directive.
    /// @note Only 1.1 and 1.2 are supported. If not, throws an exception.
    /// @return lexical_token_t The lexical token type for YAML version directives.
    lexical_token_t scan_yaml_version_directive() {
        m_token_begin_itr = m_cur_itr;

        bool ends_loop = false;
        while (!ends_loop && m_cur_itr != m_end_itr) {
            switch (*m_cur_itr) {
            case ' ':
            case '\t':
            case '\n':
                ends_loop = true;
                break;
            default:
                ++m_cur_itr;
                break;
            }
        }

        m_yaml_version = str_view {m_token_begin_itr, m_cur_itr};

        if FK_YAML_UNLIKELY (m_yaml_version.compare("1.1") != 0 && m_yaml_version.compare("1.2") != 0) {
            emit_error("Only 1.1 and 1.2 can be specified as the YAML version.");
        }

        return lexical_token_t::YAML_VER_DIRECTIVE;
    }

    /// @brief Extracts an anchor name from the input.
    /// @return The extracted anchor name.
    str_view extract_anchor_name() {
        FK_YAML_ASSERT(*m_cur_itr == '&' || *m_cur_itr == '*');

        m_token_begin_itr = ++m_cur_itr;

        bool ends_loop = false;
        for (; m_cur_itr != m_end_itr; ++m_cur_itr) {
            switch (*m_cur_itr) {
            // anchor name must not contain white spaces, newline codes and flow indicators.
            // See https://yaml.org/spec/1.2.2/#692-node-anchors for more details.
            case ' ':
            case '\t':
            case '\n':
            case '{':
            case '}':
            case '[':
            case ']':
            case ',':
                ends_loop = true;
                break;
            default:
                break;
            }

            if (ends_loop) {
                break;
            }
        }

        if FK_YAML_UNLIKELY (m_token_begin_itr == m_cur_itr) {
            emit_error("anchor name must not be empty.");
        }

        return {m_token_begin_itr, m_cur_itr};
    }

    /// @brief Extracts a tag name from the input.
    /// @return A tag name.
    str_view extract_tag_name() {
        FK_YAML_ASSERT(*m_cur_itr == '!');

        if (++m_cur_itr == m_end_itr) {
            // Just "!" is a non-specific tag.
            return {m_token_begin_itr, m_end_itr};
        }

        bool is_verbatim = false;
        bool allows_another_tag_prefix = false;

        switch (*m_cur_itr) {
        case ' ':
        case '\n':
            // Just "!" is a non-specific tag.
            return {m_token_begin_itr, m_cur_itr};
        case '!':
            // Secondary tag handles (!!suffix)
            break;
        case '<':
            // Verbatim tags (!<TAG>)
            is_verbatim = true;
            ++m_cur_itr;
            break;
        default:
            // Either local tags (!suffix) or named handles (!tag!suffix)
            allows_another_tag_prefix = true;
            break;
        }

        bool is_named_handle = false;
        bool ends_loop = false;
        do {
            if (++m_cur_itr == m_end_itr) {
                break;
            }

            switch (*m_cur_itr) {
            // Tag names must not contain spaces or newline codes.
            case ' ':
            case '\t':
            case '\n':
                ends_loop = true;
                break;
            case '!':
                if FK_YAML_UNLIKELY (!allows_another_tag_prefix) {
                    emit_error("invalid tag prefix (!) is found.");
                }

                is_named_handle = true;
                // tag prefix must not appear three times.
                allows_another_tag_prefix = false;
                break;
            default:
                break;
            }
        } while (!ends_loop);

        str_view tag_name {m_token_begin_itr, m_cur_itr};

        if (is_verbatim) {
            const char last = tag_name.back();
            if FK_YAML_UNLIKELY (last != '>') {
                emit_error("verbatim tag (!<TAG>) must be ended with \'>\'.");
            }

            // only the `TAG` part of the `!<TAG>` for URI validation.
            const str_view tag_body = tag_name.substr(2, tag_name.size() - 3);
            if FK_YAML_UNLIKELY (tag_body.empty()) {
                emit_error("verbatim tag(!<TAG>) must not be empty.");
            }

            const bool is_valid_uri = uri_encoding::validate(tag_body.begin(), tag_body.end());
            if FK_YAML_UNLIKELY (!is_valid_uri) {
                emit_error("invalid URI character is found in a verbatim tag.");
            }

            return tag_name;
        }

        if (is_named_handle) {
            const char last = tag_name.back();
            if FK_YAML_UNLIKELY (last == '!') {
                // Tag shorthand must be followed by a non-empty suffix.
                // See the "Tag Shorthands" section in https://yaml.org/spec/1.2.2/#691-node-tags.
                emit_error("named handle has no suffix.");
            }
        }

        // get the position of last tag prefix character (!) to extract body of tag shorthands.
        // tag shorthand is either primary(!tag), secondary(!!tag) or named(!handle!tag).
        const std::size_t last_tag_prefix_pos = tag_name.find_last_of('!');
        FK_YAML_ASSERT(last_tag_prefix_pos != str_view::npos);

        const str_view tag_uri = tag_name.substr(last_tag_prefix_pos + 1);
        const bool is_valid_uri = uri_encoding::validate(tag_uri.begin(), tag_uri.end());
        if FK_YAML_UNLIKELY (!is_valid_uri) {
            emit_error("Invalid URI character is found in a named tag handle.");
        }

        // Tag shorthands cannot contain flow indicators({}[],).
        // See the "Tag Shorthands" section in https://yaml.org/spec/1.2.2/#691-node-tags.
        const std::size_t invalid_char_pos = tag_uri.find_first_of("{}[],");
        if (invalid_char_pos != str_view::npos) {
            emit_error("Tag shorthand cannot contain flow indicators({}[],).");
        }

        return tag_name;
    }

    /// @brief Determines the range of single quoted scalar by scanning remaining input buffer contents.
    /// @return A single quoted scalar.
    str_view determine_single_quoted_scalar_range() {
        const str_view sv {m_token_begin_itr, m_end_itr};

        std::size_t pos = sv.find('\'');
        while (pos != str_view::npos) {
            FK_YAML_ASSERT(pos < sv.size());
            if FK_YAML_LIKELY (pos == sv.size() - 1 || sv[pos + 1] != '\'') {
                // closing single quote is found.
                m_cur_itr = m_token_begin_itr + (pos + 1);
                str_view single_quoted_scalar {m_token_begin_itr, pos};
                check_scalar_content(single_quoted_scalar);
                return single_quoted_scalar;
            }

            // If single quotation marks are repeated twice in a single quoted scalar, they are considered as an
            // escaped single quotation mark. Skip the second one which would otherwise be detected as a closing
            // single quotation mark in the next loop.
            pos = sv.find('\'', pos + 2);
        }

        m_cur_itr = m_end_itr; // update for error information
        emit_error("Invalid end of input buffer in a single-quoted scalar token.");
    }

    /// @brief Determines the range of double quoted scalar by scanning remaining input buffer contents.
    /// @return A double quoted scalar.
    str_view determine_double_quoted_scalar_range() {
        const str_view sv {m_token_begin_itr, m_end_itr};

        std::size_t pos = sv.find('\"');
        while (pos != str_view::npos) {
            FK_YAML_ASSERT(pos < sv.size());

            bool is_closed = true;
            if FK_YAML_LIKELY (pos > 0) {
                // Double quotation marks can be escaped by a preceding backslash and the number of backslashes matters
                // to determine if the found double quotation mark is escaped since the backslash itself can also be
                // escaped:
                // * odd number of backslashes  -> double quotation mark IS escaped (e.g., "\\\"")
                // * even number of backslashes -> double quotation mark IS NOT escaped (e.g., "\\"")
                uint32_t backslash_counts = 0;
                const char* p = m_token_begin_itr + (pos - 1);
                do {
                    if (*p-- != '\\') {
                        break;
                    }
                    ++backslash_counts;
                } while (p != m_token_begin_itr);
                is_closed = ((backslash_counts & 1u) == 0); // true: even, false: odd
            }

            if (is_closed) {
                // closing double quote is found.
                m_cur_itr = m_token_begin_itr + (pos + 1);
                str_view double_quoted_scalar {m_token_begin_itr, pos};
                check_scalar_content(double_quoted_scalar);
                return double_quoted_scalar;
            }

            pos = sv.find('\"', pos + 1);
        }

        m_cur_itr = m_end_itr; // update for error information
        emit_error("Invalid end of input buffer in a double-quoted scalar token.");
    }

    /// @brief Determines the range of plain scalar by scanning remaining input buffer contents.
    /// @return A plain scalar.
    str_view determine_plain_scalar_range() {
        const str_view sv {m_token_begin_itr, m_end_itr};

        // flow indicators are checked only within a flow context.
        const str_view filter = (m_state & flow_context_bit) ? "\t\n :{}[]," : "\t\n :";
        std::size_t pos = sv.find_first_of(filter);
        if FK_YAML_UNLIKELY (pos == str_view::npos) {
            check_scalar_content(sv);
            m_cur_itr = m_end_itr;
            return sv;
        }

        bool ends_loop = false;
        uint32_t indent = std::numeric_limits<uint32_t>::max();
        do {
            FK_YAML_ASSERT(pos < sv.size());
            switch (sv[pos]) {
            case '\n': {
                if (indent == std::numeric_limits<uint32_t>::max()) {
                    indent = get_current_indent_level(&sv[pos]);
                }

                constexpr str_view space_filter {" \t\n"};
                const std::size_t non_space_pos = sv.find_first_not_of(space_filter, pos);
                const std::size_t last_newline_pos = sv.find_last_of('\n', non_space_pos);
                FK_YAML_ASSERT(last_newline_pos != str_view::npos);

                if (non_space_pos == str_view::npos || non_space_pos - last_newline_pos - 1 <= indent) {
                    ends_loop = true;
                    break;
                }

                pos = non_space_pos;
                break;
            }
            case ' ':
            case '\t':
                if FK_YAML_UNLIKELY (pos == sv.size() - 1) {
                    // trim trailing space.
                    ends_loop = true;
                    break;
                }

                // Allow a space in a plain scalar only if the space is surrounded by non-space characters, but not
                // followed by the comment prefix " #".
                // Also, flow indicators are not allowed to be followed after a space in a flow context.
                // See https://yaml.org/spec/1.2.2/#733-plain-style for more details.
                switch (sv[pos + 1]) {
                case ' ':
                case '\t':
                case '\n':
                case '#':
                    ends_loop = true;
                    break;
                case ':':
                    // " :" is permitted in a plain style string token, but not when followed by a space.
                    ends_loop = (pos < sv.size() - 2) && (sv[pos + 2] == ' ');
                    break;
                case '{':
                case '}':
                case '[':
                case ']':
                case ',':
                    ends_loop = (m_state & flow_context_bit);
                    break;
                default:
                    break;
                }
                break;
            case ':':
                if FK_YAML_LIKELY (pos + 1 < sv.size()) {
                    switch (sv[pos + 1]) {
                    case ' ':
                    case '\t':
                    case '\n':
                        ends_loop = true;
                        break;
                    default:
                        break;
                    }
                }
                break;
            case '{':
            case '}':
            case '[':
            case ']':
            case ',':
                // This check is enabled only in a flow context.
                ends_loop = true;
                break;
            default:                   // LCOV_EXCL_LINE
                detail::unreachable(); // LCOV_EXCL_LINE
            }

            if (ends_loop) {
                break;
            }

            pos = sv.find_first_of(filter, pos + 1);
        } while (pos != str_view::npos);

        str_view plain_scalar = sv.substr(0, pos);
        check_scalar_content(plain_scalar);
        m_cur_itr = plain_scalar.end();
        return plain_scalar;
    }

    /// @brief Scan a block style string token either in the literal or folded style.
    /// @param base_indent The base indent level of the block scalar.
    /// @param indicated_indent The indicated indent level in the block scalar header. 0 means it's not indicated.
    /// @param token Storage for the scanned block scalar range.
    /// @return The content indentation level of the block scalar.
    str_view determine_block_scalar_content_range(
        uint32_t base_indent, uint32_t indicated_indent, uint32_t& content_indent) {
        const str_view sv {m_token_begin_itr, m_end_itr};
        const std::size_t remain_input_len = sv.size();

        // Handle leading all-space lines.
        uint32_t cur_indent = 0;
        uint32_t max_leading_indent = 0;
        const char* cur_itr = m_token_begin_itr;
        bool stop_increment = false;

        while (cur_itr != m_end_itr) {
            switch (*cur_itr++) {
            case ' ':
                if FK_YAML_LIKELY (!stop_increment) {
                    ++cur_indent;
                }
                continue;
            case '\t':
                // Tabs are not counted as an indent character but still part of an empty line.
                // See https://yaml.org/spec/1.2.2/#rule-s-indent and https://yaml.org/spec/1.2.2/#64-empty-lines.
                stop_increment = true;
                continue;
            case '\n':
                max_leading_indent = std::max(cur_indent, max_leading_indent);
                cur_indent = 0;
                stop_increment = false;
                continue;
            default:
                break;
            }
            break;
        }

        // all the block scalar contents are empty lines, and no subsequent token exists.
        if FK_YAML_UNLIKELY (cur_itr == m_end_itr) {
            // Without the following iterator update, lexer cannot reach the end of input buffer and causes infinite
            // loops from the next loop. (https://github.com/fktn-k/fkYAML/pull/410)
            m_cur_itr = m_end_itr;

            // If there's no non-empty line, the content indentation level is equal to the number of spaces on the
            // longest line. https://yaml.org/spec/1.2.2/#8111-block-indentation-indicator
            content_indent =
                indicated_indent == 0 ? std::max(cur_indent, max_leading_indent) : base_indent + indicated_indent;
            return sv;
        }

        // Any leading empty line must not contain more spaces than the first non-empty line.
        if FK_YAML_UNLIKELY (cur_indent < max_leading_indent) {
            emit_error("Any leading empty line must not be more indented than the first non-empty line.");
        }

        if (indicated_indent == 0) {
            FK_YAML_ASSERT(base_indent < cur_indent);
            indicated_indent = cur_indent - base_indent;
        }
        else if FK_YAML_UNLIKELY (cur_indent < base_indent + indicated_indent) {
            emit_error("The first non-empty line in the block scalar is less indented.");
        }

        std::size_t last_newline_pos = sv.find('\n', cur_itr - m_token_begin_itr + 1);
        if (last_newline_pos == str_view::npos) {
            last_newline_pos = remain_input_len;
        }

        content_indent = base_indent + indicated_indent;
        while (last_newline_pos < remain_input_len) {
            std::size_t cur_line_end_pos = sv.find('\n', last_newline_pos + 1);
            if (cur_line_end_pos == str_view::npos) {
                cur_line_end_pos = remain_input_len;
            }

            const std::size_t cur_line_content_begin_pos = sv.find_first_not_of(' ', last_newline_pos + 1);
            if (cur_line_content_begin_pos == str_view::npos) {
                last_newline_pos = cur_line_end_pos;
                continue;
            }

            FK_YAML_ASSERT(last_newline_pos < cur_line_content_begin_pos);
            cur_indent = static_cast<uint32_t>(cur_line_content_begin_pos - last_newline_pos - 1);
            if (cur_indent < content_indent && sv[cur_line_content_begin_pos] != '\n') {
                if FK_YAML_UNLIKELY (cur_indent > base_indent) {
                    // This path assumes an input like the following:
                    // ```yaml
                    // foo: |
                    //   text
                    //  invalid # this line is less indented than the content indent level (2)
                    //          # but more indented than the base indent level (0)
                    // ```
                    // In such cases, the less indented line cannot be the start of the next token.
                    emit_error("A content line of the block scalar is less indented.");
                }

                // Interpret less indented non-space characters as the start of the next token.
                break;
            }

            last_newline_pos = cur_line_end_pos;
        }

        // include last newline character if not all characters have been consumed yet.
        if (last_newline_pos < remain_input_len) {
            ++last_newline_pos;
        }

        m_cur_itr = m_token_begin_itr + last_newline_pos;
        return sv.substr(0, last_newline_pos);
    }

    /// @brief Checks if the given scalar contains no unescaped control characters.
    /// @param scalar Scalar contents.
    void check_scalar_content(const str_view& scalar) const {
        const char* p_current = scalar.begin();
        const char* p_end = scalar.end();

        while (p_current != p_end) {
            const uint32_t num_bytes = utf8::get_num_bytes(static_cast<uint8_t>(*p_current));
            if (num_bytes > 1) {
                // Multibyte characters are already checked in the input_adapter module.
                p_current += num_bytes;
                continue;
            }

            switch (*p_current++) {
            // 0x00(NULL) has already been handled above.
            case 0x01:
                emit_error("Control character U+0001 (SOH) must be escaped to \\u0001.");
            case 0x02:
                emit_error("Control character U+0002 (STX) must be escaped to \\u0002.");
            case 0x03:
                emit_error("Control character U+0003 (ETX) must be escaped to \\u0003.");
            case 0x04:
                emit_error("Control character U+0004 (EOT) must be escaped to \\u0004.");
            case 0x05:
                emit_error("Control character U+0005 (ENQ) must be escaped to \\u0005.");
            case 0x06:
                emit_error("Control character U+0006 (ACK) must be escaped to \\u0006.");
            case 0x07:
                emit_error("Control character U+0007 (BEL) must be escaped to \\a or \\u0007.");
            case 0x08:
                emit_error("Control character U+0008 (BS) must be escaped to \\b or \\u0008.");
            case 0x09: // HT
                // horizontal tabs (\t) are safe to use without escaping.
                break;
            // 0x0A(LF) has already been handled above.
            case 0x0B:
                emit_error("Control character U+000B (VT) must be escaped to \\v or \\u000B.");
            case 0x0C:
                emit_error("Control character U+000C (FF) must be escaped to \\f or \\u000C.");
            // 0x0D(CR) has already been handled above.
            case 0x0E:
                emit_error("Control character U+000E (SO) must be escaped to \\u000E.");
            case 0x0F:
                emit_error("Control character U+000F (SI) must be escaped to \\u000F.");
            case 0x10:
                emit_error("Control character U+0010 (DLE) must be escaped to \\u0010.");
            case 0x11:
                emit_error("Control character U+0011 (DC1) must be escaped to \\u0011.");
            case 0x12:
                emit_error("Control character U+0012 (DC2) must be escaped to \\u0012.");
            case 0x13:
                emit_error("Control character U+0013 (DC3) must be escaped to \\u0013.");
            case 0x14:
                emit_error("Control character U+0014 (DC4) must be escaped to \\u0014.");
            case 0x15:
                emit_error("Control character U+0015 (NAK) must be escaped to \\u0015.");
            case 0x16:
                emit_error("Control character U+0016 (SYN) must be escaped to \\u0016.");
            case 0x17:
                emit_error("Control character U+0017 (ETB) must be escaped to \\u0017.");
            case 0x18:
                emit_error("Control character U+0018 (CAN) must be escaped to \\u0018.");
            case 0x19:
                emit_error("Control character U+0019 (EM) must be escaped to \\u0019.");
            case 0x1A:
                emit_error("Control character U+001A (SUB) must be escaped to \\u001A.");
            case 0x1B:
                emit_error("Control character U+001B (ESC) must be escaped to \\e or \\u001B.");
            case 0x1C:
                emit_error("Control character U+001C (FS) must be escaped to \\u001C.");
            case 0x1D:
                emit_error("Control character U+001D (GS) must be escaped to \\u001D.");
            case 0x1E:
                emit_error("Control character U+001E (RS) must be escaped to \\u001E.");
            case 0x1F:
                emit_error("Control character U+001F (US) must be escaped to \\u001F.");
            default:
                break;
            }
        }
    }

    /// @brief Gets the metadata of a following block style string scalar.
    /// @param chomp_type A variable to store the retrieved chomping style type.
    /// @param indent A variable to store the retrieved indent size.
    /// @return Block scalar header information converted from the header line.
    block_scalar_header convert_to_block_scalar_header(str_view line) {
        constexpr str_view comment_prefix {" #"};
        const std::size_t comment_begin_pos = line.find(comment_prefix);
        if (comment_begin_pos != str_view::npos) {
            line = line.substr(0, comment_begin_pos);
        }

        if (line.empty()) {
            return {};
        }

        block_scalar_header header {};
        for (const char c : line) {
            switch (c) {
            case '-':
                if FK_YAML_UNLIKELY (header.chomp != chomping_indicator_t::CLIP) {
                    emit_error("Too many block chomping indicators specified.");
                }
                header.chomp = chomping_indicator_t::STRIP;
                break;
            case '+':
                if FK_YAML_UNLIKELY (header.chomp != chomping_indicator_t::CLIP) {
                    emit_error("Too many block chomping indicators specified.");
                }
                header.chomp = chomping_indicator_t::KEEP;
                break;
            case '0':
                emit_error("An indentation level for a block scalar cannot be 0.");
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                if FK_YAML_UNLIKELY (header.indent > 0) {
                    emit_error("Invalid indentation level for a block scalar. It must be between 1 and 9.");
                }
                header.indent = static_cast<uint32_t>(c - '0');
                break;
            case ' ':
            case '\t':
                break;
            default:
                emit_error("Invalid character found in a block scalar header.");
            }
        }

        return header;
    }

    /// @brief Skip white spaces (half-width spaces and tabs) from the current position.
    void skip_white_spaces() {
        m_cur_itr = std::find_if_not(m_cur_itr, m_end_itr, [](char c) { return (c == ' ' || c == '\t'); });
    }

    /// @brief Skip white spaces and newline codes (CR/LF) from the current position.
    void skip_white_spaces_and_newline_codes() {
        if (m_cur_itr != m_end_itr) {
            m_cur_itr = std::find_if_not(m_cur_itr, m_end_itr, [](char c) {
                switch (c) {
                case ' ':
                case '\t':
                case '\n':
                    return true;
                default:
                    return false;
                }
            });
        }
    }

    /// @brief Skip the rest in the current line.
    void skip_until_line_end() {
        while (m_cur_itr != m_end_itr) {
            switch (*m_cur_itr) {
            case '\n':
                ++m_cur_itr;
                return;
            default:
                ++m_cur_itr;
                break;
            }
        }
    }

    /// @brief Emits an error with the given message.
    /// @param msg A message for the resulting error.
    [[noreturn]] void emit_error(const char* msg) const {
        m_pos_tracker.update_position(m_cur_itr);
        throw fkyaml::parse_error(msg, m_pos_tracker.get_lines_read(), m_pos_tracker.get_cur_pos_in_line());
    }

private:
    /// The iterator to the first element in the input buffer.
    const char* m_begin_itr {};
    /// The iterator to the current character in the input buffer.
    const char* m_cur_itr {};
    /// The iterator to the beginning of the current token.
    const char* m_token_begin_itr {};
    /// The iterator to the past-the-end element in the input buffer.
    const char* m_end_itr {};
    /// The current position tracker of the input buffer.
    mutable position_tracker m_pos_tracker {};
    /// The last yaml version.
    str_view m_yaml_version;
    /// The last tag handle.
    str_view m_tag_handle;
    /// The last tag prefix.
    str_view m_tag_prefix;
    /// The last block scalar header.
    block_scalar_header m_block_scalar_header {};
    /// The beginning position of the last lexical token. (zero origin)
    uint32_t m_last_token_begin_pos {0};
    /// The beginning line of the last lexical token. (zero origin)
    uint32_t m_last_token_begin_line {0};
    /// The current depth of flow context.
    uint32_t m_state {0};
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_LEXICAL_ANALYZER_HPP */

// #include <fkYAML/detail/input/scalar_parser.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_SCALAR_PARSER_HPP
#define FK_YAML_DETAIL_INPUT_SCALAR_PARSER_HPP

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/detail/conversions/scalar_conv.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

// **NOTE FOR LIBRARY DEVELOPERS**:
// Implementations in this header file are intentionally optimized for conversions between YAML scalars and native C++
// types. So, some implementations don't follow the conversions in the standard C++ functions. For example, octals must
// begin with "0o" (not "0"), which is specified in the YAML spec 1.2.

#ifndef FK_YAML_CONVERSIONS_SCALAR_CONV_HPP
#define FK_YAML_CONVERSIONS_SCALAR_CONV_HPP

#include <cmath>
#include <cstdint>
#include <cstring>
#include <limits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>


#if FK_YAML_HAS_TO_CHARS
// Prefer std::to_chars() and std::from_chars() functions if available.
#include <charconv>
#else
// Fallback to legacy string conversion functions otherwise.
#include <string> // std::stof(), std::stod(), std::stold()
#endif

FK_YAML_DETAIL_NAMESPACE_BEGIN

//////////////////////////
//   conv_limits_base   //
//////////////////////////

/// @brief A structure which provides limits for conversions between scalars and integers.
/// @note This structure contains common limits in both signed and unsigned integers.
/// @tparam NumBytes The number of bytes for the integer type.
template <std::size_t NumBytes>
struct conv_limits_base {};

/// @brief The specialization of conv_limits_base for 1 byte integers, e.g., int8_t, uint8_t.
template <>
struct conv_limits_base<1u> {
    /// max characters for octals (0o377) without the prefix part.
    static constexpr std::size_t max_chars_oct = 3;
    /// max characters for hexadecimals (0xFF) without the prefix part.
    static constexpr std::size_t max_chars_hex = 2;

    /// @brief Check if the given octals are safely converted into 1 byte integer.
    /// @param octs The pointer to octal characters
    /// @param len The length of octal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_octs_safe(const char* octs, std::size_t len) noexcept {
        return (len < max_chars_oct) || (len == max_chars_oct && octs[0] <= '3');
    }

    /// @brief Check if the given hexadecimals are safely converted into 1 byte integer.
    /// @param octs The pointer to hexadecimal characters
    /// @param len The length of hexadecimal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_hexs_safe(const char* /*unused*/, std::size_t len) noexcept {
        return len <= max_chars_hex;
    }
};

/// @brief The specialization of conv_limits_base for 2 byte integers, e.g., int16_t, uint16_t.
template <>
struct conv_limits_base<2u> {
    /// max characters for octals (0o177777) without the prefix part.
    static constexpr std::size_t max_chars_oct = 6;
    /// max characters for hexadecimals (0xFFFF) without the prefix part.
    static constexpr std::size_t max_chars_hex = 4;

    /// @brief Check if the given octals are safely converted into 2 byte integer.
    /// @param octs The pointer to octal characters
    /// @param len The length of octal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_octs_safe(const char* octs, std::size_t len) noexcept {
        return (len < max_chars_oct) || (len == max_chars_oct && octs[0] <= '1');
    }

    /// @brief Check if the given hexadecimals are safely converted into 2 byte integer.
    /// @param octs The pointer to hexadecimal characters
    /// @param len The length of hexadecimal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_hexs_safe(const char* /*unused*/, std::size_t len) noexcept {
        return len <= max_chars_hex;
    }
};

/// @brief The specialization of conv_limits_base for 4 byte integers, e.g., int32_t, uint32_t.
template <>
struct conv_limits_base<4u> {
    /// max characters for octals (0o37777777777) without the prefix part.
    static constexpr std::size_t max_chars_oct = 11;
    /// max characters for hexadecimals (0xFFFFFFFF) without the prefix part.
    static constexpr std::size_t max_chars_hex = 8;

    /// @brief Check if the given octals are safely converted into 4 byte integer.
    /// @param octs The pointer to octal characters
    /// @param len The length of octal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_octs_safe(const char* octs, std::size_t len) noexcept {
        return (len < max_chars_oct) || (len == max_chars_oct && octs[0] <= '3');
    }

    /// @brief Check if the given hexadecimals are safely converted into 4 byte integer.
    /// @param octs The pointer to hexadecimal characters
    /// @param len The length of hexadecimal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_hexs_safe(const char* /*unused*/, std::size_t len) noexcept {
        return len <= max_chars_hex;
    }
};

/// @brief The specialization of conv_limits_base for 8 byte integers, e.g., int64_t, uint64_t.
template <>
struct conv_limits_base<8u> {
    /// max characters for octals (0o1777777777777777777777) without the prefix part.
    static constexpr std::size_t max_chars_oct = 22;
    /// max characters for hexadecimals (0xFFFFFFFFFFFFFFFF) without the prefix part.
    static constexpr std::size_t max_chars_hex = 16;

    /// @brief Check if the given octals are safely converted into 8 byte integer.
    /// @param octs The pointer to octal characters
    /// @param len The length of octal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_octs_safe(const char* octs, std::size_t len) noexcept {
        return (len < max_chars_oct) || (len == max_chars_oct && octs[0] <= '1');
    }

    /// @brief Check if the given hexadecimals are safely converted into 8 byte integer.
    /// @param octs The pointer to hexadecimal characters
    /// @param len The length of hexadecimal characters
    /// @return true is safely convertible, false otherwise.
    static bool check_if_hexs_safe(const char* /*unused*/, std::size_t len) noexcept {
        return len <= max_chars_hex;
    }
};

/////////////////////
//   conv_limits   //
/////////////////////

/// @brief A structure which provides limits for conversions between scalars and integers.
/// @note This structure contains limits which differs based on signedness.
/// @tparam NumBytes The number of bytes for the integer type.
/// @tparam IsSigned Whether an integer is signed or unsigned
template <std::size_t NumBytes, bool IsSigned>
struct conv_limits {};

/// @brief The specialization of conv_limits for 1 byte signed integers, e.g., int8_t.
template <>
struct conv_limits<1u, true> : conv_limits_base<1u> {
    /// with or without sign.
    static constexpr bool is_signed = true;

    /// max characters for decimals (-128..127) without sign.
    static constexpr std::size_t max_chars_dec = 3;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        // Making this function a static constexpr variable, a link error happens.
        // Although the issue has been fixed since C++17, this workaround is necessary to let this functionality work
        // with C++11 (the library's default C++ standard version).
        // The same thing is applied to similar functions in the other specializations.

        static constexpr char max_value_chars[] = "127";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value without sign.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "128";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 1 byte unsigned integers, e.g., uint8_t.
template <>
struct conv_limits<1u, false> : conv_limits_base<1u> {
    /// with or without sign.
    static constexpr bool is_signed = false;

    /// max characters for decimals (0..255) without sign.
    static constexpr std::size_t max_chars_dec = 3;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "255";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "0";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 2 byte signed integers, e.g., int16_t.
template <>
struct conv_limits<2u, true> : conv_limits_base<2u> {
    /// with or without sign.
    static constexpr bool is_signed = true;

    /// max characters for decimals (-32768..32767) without sign.
    static constexpr std::size_t max_chars_dec = 5;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "32767";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value without sign.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "32768";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 2 byte unsigned integers, e.g., uint16_t.
template <>
struct conv_limits<2u, false> : conv_limits_base<2u> {
    /// with or without sign.
    static constexpr bool is_signed = false;

    /// max characters for decimals (0..65535) without sign.
    static constexpr std::size_t max_chars_dec = 5;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "65535";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "0";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 4 byte signed integers, e.g., int32_t.
template <>
struct conv_limits<4u, true> : conv_limits_base<4u> {
    /// with or without sign.
    static constexpr bool is_signed = true;

    /// max characters for decimals (-2147483648..2147483647) without sign.
    static constexpr std::size_t max_chars_dec = 10;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "2147483647";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value without sign.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "2147483648";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 4 byte unsigned integers, e.g., uint32_t.
template <>
struct conv_limits<4u, false> : conv_limits_base<4u> {
    /// with or without sign.
    static constexpr bool is_signed = false;

    /// max characters for decimals (0..4294967295) without sign.
    static constexpr std::size_t max_chars_dec = 10;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "4294967295";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "0";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 8 byte signed integers, e.g., int64_t.
template <>
struct conv_limits<8u, true> : conv_limits_base<8u> {
    /// with or without sign.
    static constexpr bool is_signed = true;

    /// max characters for decimals (-9223372036854775808..9223372036854775807) without sign.
    static constexpr std::size_t max_chars_dec = 19;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "9223372036854775807";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value without sign.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "9223372036854775808";
        return &min_value_chars[0];
    }
};

/// @brief The specialization of conv_limits for 8 byte unsigned integers, e.g., uint64_t.
template <>
struct conv_limits<8u, false> : conv_limits_base<8u> {
    /// with or without sign.
    static constexpr bool is_signed = false;

    /// max characters for decimals (0..18446744073709551615) without sign.
    static constexpr std::size_t max_chars_dec = 20;

    /// string representation of max decimal value.
    static const char* max_value_chars_dec() noexcept {
        static constexpr char max_value_chars[] = "18446744073709551615";
        return &max_value_chars[0];
    }

    /// string representation of min decimal value.
    static const char* min_value_chars_dec() noexcept {
        static constexpr char min_value_chars[] = "0";
        return &min_value_chars[0];
    }
};

//////////////////////////
//   scalar <--> null   //
//////////////////////////

/// @brief Converts a scalar into a null value
/// @tparam CharItr Type of char iterators. Its value type must be `char` (maybe cv-qualified).
/// @param begin The iterator to the first element of the scalar.
/// @param end The iterator to the past-the-end element of the scalar.
/// @param /*unused*/ The null value holder (unused since it can only have `nullptr`)
/// @return true if the conversion completes successfully, false otherwise.
template <typename CharItr>
inline bool aton(CharItr begin, CharItr end, std::nullptr_t& /*unused*/) noexcept {
    static_assert(is_iterator_of<CharItr, char>::value, "aton() accepts iterators for char type");

    if FK_YAML_UNLIKELY (begin == end) {
        return false;
    }

    const auto len = static_cast<uint32_t>(std::distance(begin, end));

    // This path is the most probable case, so check it first.
    if FK_YAML_LIKELY (len == 4) {
        const char* p_begin = &*begin;
        return (std::strncmp(p_begin, "null", 4) == 0) || (std::strncmp(p_begin, "Null", 4) == 0) ||
               (std::strncmp(p_begin, "NULL", 4) == 0);
    }

    if (len == 1) {
        return *begin == '~';
    }

    return false;
}

/////////////////////////////
//   scalar <--> boolean   //
/////////////////////////////

/// @brief Converts a scalar into a boolean value
/// @tparam CharItr The type of char iterators. Its value type must be `char` (maybe cv-qualified).
/// @tparam BoolType The output boolean type.
/// @param begin The iterator to the first element of the scalar.
/// @param end The iterator to the past-the-end element of the scalar.
/// @param boolean The boolean value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename CharItr, typename BoolType>
inline bool atob(CharItr begin, CharItr end, BoolType& boolean) noexcept {
    static_assert(is_iterator_of<CharItr, char>::value, "atob() accepts iterators for char type");

    if FK_YAML_UNLIKELY (begin == end) {
        return false;
    }

    const auto len = static_cast<uint32_t>(std::distance(begin, end));
    const char* p_begin = &*begin;

    if (len == 4) {
        const bool is_true = (std::strncmp(p_begin, "true", 4) == 0) || (std::strncmp(p_begin, "True", 4) == 0) ||
                             (std::strncmp(p_begin, "TRUE", 4) == 0);

        if FK_YAML_LIKELY (is_true) {
            boolean = static_cast<BoolType>(true);
        }
        return is_true;
    }

    if (len == 5) {
        const bool is_false = (std::strncmp(p_begin, "false", 5) == 0) || (std::strncmp(p_begin, "False", 5) == 0) ||
                              (std::strncmp(p_begin, "FALSE", 5) == 0);

        if FK_YAML_LIKELY (is_false) {
            boolean = static_cast<BoolType>(false);
        }
        return is_false;
    }

    return false;
}

/////////////////////////////
//   scalar <--> integer   //
/////////////////////////////

//
// scalar --> decimals
//

/// @brief Converts a scalar into decimals. This is common implementation for both signed/unsigned integer types.
/// @warning
/// This function does NOT care about overflows if IntType is unsigned. The source string value must be validated
/// beforehand by calling either atoi_dec_pos() or atoi_dec_neg() functions.
/// Furthermore, `p_begin` and `p_end` must NOT be null. Validate them before calling this function.
/// @tparam IntType The output integer type. It can be either signed or unsigned.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename IntType>
inline bool atoi_dec_unchecked(const char* p_begin, const char* p_end, IntType& i) noexcept {
    static_assert(
        is_non_bool_integral<IntType>::value,
        "atoi_dec_unchecked() accepts non-boolean integral types as an output type");

    i = 0;
    do {
        const char c = *p_begin;
        if FK_YAML_UNLIKELY (c < '0' || '9' < c) {
            return false;
        }
        // Overflow is intentional when the IntType is signed.
        i = i * static_cast<IntType>(10) + static_cast<IntType>(c - '0');
    } while (++p_begin != p_end);

    return true;
}

/// @brief Converts a scalar into positive decimals. This function executes bounds check to avoid overflow.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @tparam IntType The output integer type. It can be either signed or unsigned.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename IntType>
inline bool atoi_dec_pos(const char* p_begin, const char* p_end, IntType& i) noexcept {
    static_assert(
        is_non_bool_integral<IntType>::value, "atoi_dec_pos() accepts non-boolean integral types as an output type");

    if FK_YAML_UNLIKELY (p_begin == p_end) {
        return false;
    }

    using conv_limits_type = conv_limits<sizeof(IntType), std::is_signed<IntType>::value>;

    const auto len = static_cast<std::size_t>(p_end - p_begin);
    if FK_YAML_UNLIKELY (len > conv_limits_type::max_chars_dec) {
        // Overflow will happen.
        return false;
    }

    if (len == conv_limits_type::max_chars_dec) {
        const char* p_max_value_chars_dec = conv_limits_type::max_value_chars_dec();

        for (std::size_t idx = 0; idx < conv_limits_type::max_chars_dec; idx++) {
            if (p_begin[idx] < p_max_value_chars_dec[idx]) {
                // No need to check the lower digits. Overflow will no longer happen.
                break;
            }

            if FK_YAML_UNLIKELY (p_begin[idx] > p_max_value_chars_dec[idx]) {
                // Overflow will happen.
                return false;
            }
        }
    }

    return atoi_dec_unchecked(p_begin, p_end, i);
}

/// @brief Converts a scalar into negative decimals. This function executes bounds check to avoid underflow.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @tparam IntType The output integer type. It must be signed.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename IntType>
inline bool atoi_dec_neg(const char* p_begin, const char* p_end, IntType& i) noexcept {
    static_assert(
        is_non_bool_integral<IntType>::value, "atoi_dec_neg() accepts non-boolean integral types as an output type");

    if FK_YAML_UNLIKELY (p_begin == p_end) {
        return false;
    }

    using conv_limits_type = conv_limits<sizeof(IntType), std::is_signed<IntType>::value>;

    const auto len = static_cast<std::size_t>(p_end - p_begin);
    if FK_YAML_UNLIKELY (len > conv_limits_type::max_chars_dec) {
        // Underflow will happen.
        return false;
    }

    if (len == conv_limits_type::max_chars_dec) {
        const char* p_min_value_chars_dec = conv_limits_type::min_value_chars_dec();

        for (std::size_t idx = 0; idx < conv_limits_type::max_chars_dec; idx++) {
            if (p_begin[idx] < p_min_value_chars_dec[idx]) {
                // No need to check the lower digits. Underflow will no longer happen.
                break;
            }

            if FK_YAML_UNLIKELY (p_begin[idx] > p_min_value_chars_dec[idx]) {
                // Underflow will happen.
                return false;
            }
        }
    }

    return atoi_dec_unchecked(p_begin, p_end, i);
}

//
// scalar --> octals
//

/// @brief Converts a scalar into octals. This function executes bounds check to avoid overflow.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @tparam IntType The output integer type. It can be either signed or unsigned.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename IntType>
inline bool atoi_oct(const char* p_begin, const char* p_end, IntType& i) noexcept {
    static_assert(
        is_non_bool_integral<IntType>::value, "atoi_oct() accepts non-boolean integral types as an output type");

    if FK_YAML_UNLIKELY (p_begin == p_end) {
        return false;
    }

    using conv_limits_type = conv_limits<sizeof(IntType), std::is_signed<IntType>::value>;

    const auto len = static_cast<std::size_t>(p_end - p_begin);
    if FK_YAML_UNLIKELY (!conv_limits_type::check_if_octs_safe(p_begin, len)) {
        return false;
    }

    i = 0;
    do {
        const char c = *p_begin;
        if FK_YAML_UNLIKELY (c < '0' || '7' < c) {
            return false;
        }
        i = i * static_cast<IntType>(8) + static_cast<IntType>(c - '0');
    } while (++p_begin != p_end);

    return true;
}

//
// scalar --> hexadecimals
//

/// @brief Converts a scalar into hexadecimals. This function executes bounds check to avoid overflow.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @tparam IntType The output integer type. It can be either signed or unsigned.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename IntType>
inline bool atoi_hex(const char* p_begin, const char* p_end, IntType& i) noexcept {
    static_assert(
        is_non_bool_integral<IntType>::value, "atoi_hex() accepts non-boolean integral types as an output type");

    if FK_YAML_UNLIKELY (p_begin == p_end) {
        return false;
    }

    using conv_limits_type = conv_limits<sizeof(IntType), std::is_signed<IntType>::value>;

    const auto len = static_cast<std::size_t>(p_end - p_begin);
    if FK_YAML_UNLIKELY (!conv_limits_type::check_if_hexs_safe(p_begin, len)) {
        return false;
    }

    i = 0;
    do {
        // NOLINTBEGIN(bugprone-misplaced-widening-cast)
        const char c = *p_begin;
        IntType ci = 0;
        if ('0' <= c && c <= '9') {
            ci = static_cast<IntType>(c - '0');
        }
        else if ('A' <= c && c <= 'F') {
            ci = static_cast<IntType>(c - 'A' + 10);
        }
        else if ('a' <= c && c <= 'f') {
            ci = static_cast<IntType>(c - 'a' + 10);
        }
        else {
            return false;
        }
        i = i * static_cast<IntType>(16) + ci;
        // NOLINTEND(bugprone-misplaced-widening-cast)
    } while (++p_begin != p_end);

    return true;
}

//
// atoi() & itoa()
//

/// @brief Converts a scalar into integers. This function executes bounds check to avoid overflow/underflow.
/// @tparam CharItr The type of char iterators. Its value type must be char (maybe cv-qualified).
/// @tparam IntType The output integer type. It can be either signed or unsigned.
/// @param begin The iterator to the first element of the scalar.
/// @param end The iterator to the past-the-end element of the scalar.
/// @param i The output integer value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename CharItr, typename IntType>
inline bool atoi(CharItr begin, CharItr end, IntType& i) noexcept {
    static_assert(is_iterator_of<CharItr, char>::value, "atoi() accepts iterators for char type");
    static_assert(is_non_bool_integral<IntType>::value, "atoi() accepts non-boolean integral types as an output type");

    if FK_YAML_UNLIKELY (begin == end) {
        return false;
    }

    const auto len = static_cast<uint32_t>(std::distance(begin, end));
    const char* p_begin = &*begin;
    const char* p_end = p_begin + len;

    const char first = *begin;
    if (first == '+') {
        return atoi_dec_pos(p_begin + 1, p_end, i);
    }

    if (first == '-') {
        if (!std::numeric_limits<IntType>::is_signed) {
            return false;
        }

        const bool success = atoi_dec_neg(p_begin + 1, p_end, i);
        if (success) {
            i *= static_cast<IntType>(-1);
        }

        return success;
    }

    if (first != '0') {
        return atoi_dec_pos(p_begin, p_end, i);
    }

    if (p_begin + 1 != p_end) {
        switch (*(p_begin + 1)) {
        case 'o':
            return atoi_oct(p_begin + 2, p_end, i);
        case 'x':
            return atoi_hex(p_begin + 2, p_end, i);
        default:
            // The YAML spec doesn't allow decimals starting with 0.
            return false;
        }
    }

    i = 0;
    return true;
}

///////////////////////////
//   scalar <--> float   //
///////////////////////////

/// @brief Set an infinite `float` value based on the given signedness.
/// @param f The output `float` value holder.
/// @param sign Whether the infinite value should be positive or negative.
inline void set_infinity(float& f, const float sign) noexcept {
    f = std::numeric_limits<float>::infinity() * sign;
}

/// @brief Set an infinite `double` value based on the given signedness.
/// @param f The output `double` value holder.
/// @param sign Whether the infinite value should be positive or negative.
inline void set_infinity(double& f, const double sign) noexcept {
    f = std::numeric_limits<double>::infinity() * sign;
}

/// @brief Set a NaN `float` value.
/// @param f The output `float` value holder.
inline void set_nan(float& f) noexcept {
    f = std::nanf("");
}

/// @brief Set a NaN `double` value.
/// @param f The output `double` value holder.
inline void set_nan(double& f) noexcept {
    f = std::nan("");
}

#if FK_YAML_HAS_TO_CHARS

/// @brief Converts a scalar into a floating point value.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param f The output floating point value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename FloatType>
inline bool atof_impl(const char* p_begin, const char* p_end, FloatType& f) noexcept {
    static_assert(std::is_floating_point_v<FloatType>, "atof_impl() accepts floating point types as an output type");
    if (auto [ptr, ec] = std::from_chars(p_begin, p_end, f); ec == std::errc {}) {
        return ptr == p_end;
    }
    return false;
}

#else

/// @brief Converts a scalar into a `float` value.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param f The output `float` value holder.
/// @return true if the conversion completes successfully, false otherwise.
inline bool atof_impl(const char* p_begin, const char* p_end, float& f) {
    std::size_t idx = 0;
    f = std::stof(std::string(p_begin, p_end), &idx);
    return idx == static_cast<std::size_t>(p_end - p_begin);
}

/// @brief Converts a scalar into a `double` value.
/// @warning `p_begin` and `p_end` must not be null. Validate them before calling this function.
/// @param p_begin The pointer to the first element of the scalar.
/// @param p_end The pointer to the past-the-end element of the scalar.
/// @param f The output `double` value holder.
/// @return true if the conversion completes successfully, false otherwise.
inline bool atof_impl(const char* p_begin, const char* p_end, double& f) {
    std::size_t idx = 0;
    f = std::stod(std::string(p_begin, p_end), &idx);
    return idx == static_cast<std::size_t>(p_end - p_begin);
}

#endif // FK_YAML_HAS_TO_CHARS

/// @brief Converts a scalar into a floating point value.
/// @tparam CharItr The type of char iterators. Its value type must be char (maybe cv-qualified).
/// @tparam FloatType The output floating point value type.
/// @param begin The iterator to the first element of the scalar.
/// @param end The iterator to the past-the-end element of the scalar.
/// @param f The output floating point value holder.
/// @return true if the conversion completes successfully, false otherwise.
template <typename CharItr, typename FloatType>
inline bool atof(CharItr begin, CharItr end, FloatType& f) noexcept(noexcept(atof_impl(&*begin, &*begin, f))) {
    static_assert(is_iterator_of<CharItr, char>::value, "atof() accepts iterators for char type");
    static_assert(std::is_floating_point<FloatType>::value, "atof() accepts floating point types as an output type");

    if FK_YAML_UNLIKELY (begin == end) {
        return false;
    }

    const auto len = static_cast<uint32_t>(std::distance(begin, end));
    const char* p_begin = &*begin;
    const char* p_end = p_begin + len;

    if (*p_begin == '-' || *p_begin == '+') {
        if (len == 5) {
            const char* p_from_second = p_begin + 1;
            const bool is_inf = (std::strncmp(p_from_second, ".inf", 4) == 0) ||
                                (std::strncmp(p_from_second, ".Inf", 4) == 0) ||
                                (std::strncmp(p_from_second, ".INF", 4) == 0);
            if (is_inf) {
                set_infinity(f, *p_begin == '-' ? static_cast<FloatType>(-1.) : static_cast<FloatType>(1.));
                return true;
            }
        }

        if (*p_begin == '+') {
            // Skip the positive sign since it's sometimes not recognized as part of float value.
            ++p_begin;
        }
    }
    else if (len == 4) {
        const bool is_inf = (std::strncmp(p_begin, ".inf", 4) == 0) || (std::strncmp(p_begin, ".Inf", 4) == 0) ||
                            (std::strncmp(p_begin, ".INF", 4) == 0);
        if (is_inf) {
            set_infinity(f, static_cast<FloatType>(1.));
            return true;
        }

        const bool is_nan = (std::strncmp(p_begin, ".nan", 4) == 0) || (std::strncmp(p_begin, ".NaN", 4) == 0) ||
                            (std::strncmp(p_begin, ".NAN", 4) == 0);
        if (is_nan) {
            set_nan(f);
            return true;
        }
    }

#if FK_YAML_HAS_TO_CHARS
    return atof_impl(p_begin, p_end, f);
#else
    bool success = false;
    try {
        success = atof_impl(p_begin, p_end, f);
    }
    catch (const std::exception& /*unused*/) {
        success = false;
    }

    return success;
#endif
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_CONVERSIONS_SCALAR_CONV_HPP */

// #include <fkYAML/detail/encodings/yaml_escaper.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ENCODINGS_YAML_ESCAPER_HPP
#define FK_YAML_DETAIL_ENCODINGS_YAML_ESCAPER_HPP

#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/detail/encodings/utf_encodings.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

class yaml_escaper {
    using iterator = ::std::string::const_iterator;

public:
    static bool unescape(const char*& begin, const char* end, std::string& buff) {
        FK_YAML_ASSERT(*begin == '\\' && std::distance(begin, end) > 0);
        bool ret = true;

        switch (*++begin) {
        case 'a':
            buff.push_back('\a');
            break;
        case 'b':
            buff.push_back('\b');
            break;
        case 't':
        case '\t':
            buff.push_back('\t');
            break;
        case 'n':
            buff.push_back('\n');
            break;
        case 'v':
            buff.push_back('\v');
            break;
        case 'f':
            buff.push_back('\f');
            break;
        case 'r':
            buff.push_back('\r');
            break;
        case 'e':
            buff.push_back(static_cast<char>(0x1B));
            break;
        case ' ':
            buff.push_back(' ');
            break;
        case '\"':
            buff.push_back('\"');
            break;
        case '/':
            buff.push_back('/');
            break;
        case '\\':
            buff.push_back('\\');
            break;
        case 'N': // next line
            unescape_escaped_unicode(0x85u, buff);
            break;
        case '_': // non-breaking space
            unescape_escaped_unicode(0xA0u, buff);
            break;
        case 'L': // line separator
            unescape_escaped_unicode(0x2028u, buff);
            break;
        case 'P': // paragraph separator
            unescape_escaped_unicode(0x2029u, buff);
            break;
        case 'x': {
            char32_t codepoint {0};
            ret = extract_codepoint(begin, end, 1, codepoint);
            if FK_YAML_LIKELY (ret) {
                unescape_escaped_unicode(codepoint, buff);
            }
            break;
        }
        case 'u': {
            char32_t codepoint {0};
            ret = extract_codepoint(begin, end, 2, codepoint);
            if FK_YAML_LIKELY (ret) {
                unescape_escaped_unicode(codepoint, buff);
            }
            break;
        }
        case 'U': {
            char32_t codepoint {0};
            ret = extract_codepoint(begin, end, 4, codepoint);
            if FK_YAML_LIKELY (ret) {
                unescape_escaped_unicode(codepoint, buff);
            }
            break;
        }
        default:
            // Unsupported escape sequence is found in a string token.
            ret = false;
            break;
        }

        return ret;
    }

    static ::std::string escape(const char* begin, const char* end, bool& is_escaped) {
        ::std::string escaped {};
        escaped.reserve(std::distance(begin, end));
        for (; begin != end; ++begin) {
            switch (*begin) {
            case 0x01:
                escaped += "\\u0001";
                is_escaped = true;
                break;
            case 0x02:
                escaped += "\\u0002";
                is_escaped = true;
                break;
            case 0x03:
                escaped += "\\u0003";
                is_escaped = true;
                break;
            case 0x04:
                escaped += "\\u0004";
                is_escaped = true;
                break;
            case 0x05:
                escaped += "\\u0005";
                is_escaped = true;
                break;
            case 0x06:
                escaped += "\\u0006";
                is_escaped = true;
                break;
            case '\a':
                escaped += "\\a";
                is_escaped = true;
                break;
            case '\b':
                escaped += "\\b";
                is_escaped = true;
                break;
            case '\t':
                escaped += "\\t";
                is_escaped = true;
                break;
            case '\n':
                escaped += "\\n";
                is_escaped = true;
                break;
            case '\v':
                escaped += "\\v";
                is_escaped = true;
                break;
            case '\f':
                escaped += "\\f";
                is_escaped = true;
                break;
            case '\r':
                escaped += "\\r";
                is_escaped = true;
                break;
            case 0x0E:
                escaped += "\\u000E";
                is_escaped = true;
                break;
            case 0x0F:
                escaped += "\\u000F";
                is_escaped = true;
                break;
            case 0x10:
                escaped += "\\u0010";
                is_escaped = true;
                break;
            case 0x11:
                escaped += "\\u0011";
                is_escaped = true;
                break;
            case 0x12:
                escaped += "\\u0012";
                is_escaped = true;
                break;
            case 0x13:
                escaped += "\\u0013";
                is_escaped = true;
                break;
            case 0x14:
                escaped += "\\u0014";
                is_escaped = true;
                break;
            case 0x15:
                escaped += "\\u0015";
                is_escaped = true;
                break;
            case 0x16:
                escaped += "\\u0016";
                is_escaped = true;
                break;
            case 0x17:
                escaped += "\\u0017";
                is_escaped = true;
                break;
            case 0x18:
                escaped += "\\u0018";
                is_escaped = true;
                break;
            case 0x19:
                escaped += "\\u0019";
                is_escaped = true;
                break;
            case 0x1A:
                escaped += "\\u001A";
                is_escaped = true;
                break;
            case 0x1B:
                escaped += "\\e";
                is_escaped = true;
                break;
            case 0x1C:
                escaped += "\\u001C";
                is_escaped = true;
                break;
            case 0x1D:
                escaped += "\\u001D";
                is_escaped = true;
                break;
            case 0x1E:
                escaped += "\\u001E";
                is_escaped = true;
                break;
            case 0x1F:
                escaped += "\\u001F";
                is_escaped = true;
                break;
            case '\"':
                escaped += "\\\"";
                is_escaped = true;
                break;
            case '\\':
                escaped += "\\\\";
                is_escaped = true;
                break;
            default:
                const std::ptrdiff_t diff = static_cast<int>(std::distance(begin, end));
                if (diff > 1) {
                    if (*begin == static_cast<char>(0xC2u) && *(begin + 1) == static_cast<char>(0x85u)) {
                        escaped += "\\N";
                        std::advance(begin, 1);
                        is_escaped = true;
                        break;
                    }
                    if (*begin == static_cast<char>(0xC2u) && *(begin + 1) == static_cast<char>(0xA0u)) {
                        escaped += "\\_";
                        std::advance(begin, 1);
                        is_escaped = true;
                        break;
                    }

                    if (diff > 2) {
                        if (*begin == static_cast<char>(0xE2u) && *(begin + 1) == static_cast<char>(0x80u) &&
                            *(begin + 2) == static_cast<char>(0xA8u)) {
                            escaped += "\\L";
                            std::advance(begin, 2);
                            is_escaped = true;
                            break;
                        }
                        if (*begin == static_cast<char>(0xE2u) && *(begin + 1) == static_cast<char>(0x80u) &&
                            *(begin + 2) == static_cast<char>(0xA9u)) {
                            escaped += "\\P";
                            std::advance(begin, 2);
                            is_escaped = true;
                            break;
                        }
                    }
                }
                escaped += *begin;
                break;
            }
        }
        return escaped;
    } // LCOV_EXCL_LINE

private:
    static bool convert_hexchar_to_byte(char source, uint8_t& byte) {
        if ('0' <= source && source <= '9') {
            // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
            byte = static_cast<uint8_t>(source - '0');
            return true;
        }

        if ('A' <= source && source <= 'F') {
            // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
            byte = static_cast<uint8_t>(source - 'A' + 10);
            return true;
        }

        if ('a' <= source && source <= 'f') {
            // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
            byte = static_cast<uint8_t>(source - 'a' + 10);
            return true;
        }

        // The given character is not hexadecimal.
        return false;
    }

    static bool extract_codepoint(const char*& begin, const char* end, int bytes_to_read, char32_t& codepoint) {
        const bool has_enough_room = static_cast<int>(std::distance(begin, end)) >= (bytes_to_read - 1);
        if (!has_enough_room) {
            return false;
        }

        const int read_size = bytes_to_read * 2;
        uint8_t byte {0};
        codepoint = 0;

        for (int i = read_size - 1; i >= 0; i--) {
            const bool is_valid = convert_hexchar_to_byte(*++begin, byte);
            if (!is_valid) {
                return false;
            }
            // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
            codepoint |= static_cast<char32_t>(byte << (4 * i));
        }

        return true;
    }

    static void unescape_escaped_unicode(char32_t codepoint, std::string& buff) {
        // the inner curly braces are necessary to build with older compilers.
        std::array<uint8_t, 4> encode_buff {{}};
        uint32_t encoded_size {0};
        utf8::from_utf32(codepoint, encode_buff, encoded_size);
        buff.append(reinterpret_cast<char*>(encode_buff.data()), encoded_size);
    }
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_ENCODINGS_YAML_ESCAPER_HPP */

// #include <fkYAML/detail/input/block_scalar_header.hpp>

// #include <fkYAML/detail/input/scalar_scanner.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_SCALAR_SCANNER_HPP
#define FK_YAML_DETAIL_INPUT_SCALAR_SCANNER_HPP

#include <cstring>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/node_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief The class which detects a scalar value type by scanning contents.
class scalar_scanner {
public:
    /// @brief Detects a scalar value type by scanning the contents ranged by the given iterators.
    /// @param begin The iterator to the first element of the scalar.
    /// @param end The iterator to the past-the-end element of the scalar.
    /// @return A detected scalar value type.
    static node_type scan(const char* begin, const char* end) noexcept {
        if (begin == end) {
            return node_type::STRING;
        }

        const auto len = static_cast<uint32_t>(std::distance(begin, end));
        if (len > 5) {
            return scan_possible_number_token(begin, len);
        }

        const char* p_begin = &*begin;

        switch (len) {
        case 1:
            if (*p_begin == '~') {
                return node_type::NULL_OBJECT;
            }
            break;
        case 4:
            switch (*p_begin) {
            case 'n':
                // no possible case of begin a number otherwise.
                return (std::strncmp(p_begin + 1, "ull", 3) == 0) ? node_type::NULL_OBJECT : node_type::STRING;
            case 'N':
                // no possible case of begin a number otherwise.
                return ((std::strncmp(p_begin + 1, "ull", 3) == 0) || (std::strncmp(p_begin + 1, "ULL", 3) == 0))
                           ? node_type::NULL_OBJECT
                           : node_type::STRING;
            case 't':
                // no possible case of being a number otherwise.
                return (std::strncmp(p_begin + 1, "rue", 3) == 0) ? node_type::BOOLEAN : node_type::STRING;
            case 'T':
                // no possible case of being a number otherwise.
                return ((std::strncmp(p_begin + 1, "rue", 3) == 0) || (std::strncmp(p_begin + 1, "RUE", 3) == 0))
                           ? node_type::BOOLEAN
                           : node_type::STRING;
            case '.': {
                const char* p_from_second = p_begin + 1;
                const bool is_inf_or_nan_scalar =
                    (std::strncmp(p_from_second, "inf", 3) == 0) || (std::strncmp(p_from_second, "Inf", 3) == 0) ||
                    (std::strncmp(p_from_second, "INF", 3) == 0) || (std::strncmp(p_from_second, "nan", 3) == 0) ||
                    (std::strncmp(p_from_second, "NaN", 3) == 0) || (std::strncmp(p_from_second, "NAN", 3) == 0);
                if (is_inf_or_nan_scalar) {
                    return node_type::FLOAT;
                }
                // maybe a number.
                break;
            }
            default:
                break;
            }
            break;
        case 5:
            switch (*p_begin) {
            case 'f':
                // no possible case of being a number otherwise.
                return (std::strncmp(p_begin + 1, "alse", 4) == 0) ? node_type::BOOLEAN : node_type::STRING;
            case 'F':
                // no possible case of being a number otherwise.
                return ((std::strncmp(p_begin + 1, "alse", 4) == 0) || (std::strncmp(p_begin + 1, "ALSE", 4) == 0))
                           ? node_type::BOOLEAN
                           : node_type::STRING;
            case '+':
            case '-':
                if (*(p_begin + 1) == '.') {
                    const char* p_from_third = p_begin + 2;
                    const bool is_min_inf = (std::strncmp(p_from_third, "inf", 3) == 0) ||
                                            (std::strncmp(p_from_third, "Inf", 3) == 0) ||
                                            (std::strncmp(p_from_third, "INF", 3) == 0);
                    if (is_min_inf) {
                        return node_type::FLOAT;
                    }
                }
                // maybe a number.
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }

        return scan_possible_number_token(begin, len);
    }

private:
    /// @brief Detects a scalar value type from the contents (possibly an integer or a floating-point value).
    /// @param itr The iterator to the first element of the scalar.
    /// @param len The length of the scalar contents.
    /// @return A detected scalar value type.
    static node_type scan_possible_number_token(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        switch (*itr) {
        case '-':
            return (len > 1) ? scan_negative_number(++itr, --len) : node_type::STRING;
        case '+':
            return (len > 1) ? scan_decimal_number(++itr, --len) : node_type::STRING;
        case '.':
            // some integer(s) required after the decimal point as a floating point value.
            return (len > 1) ? scan_after_decimal_point(++itr, --len) : node_type::STRING;
        case '0':
            return (len > 1) ? scan_after_zero_at_first(++itr, --len) : node_type::INTEGER;
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            return (len > 1) ? scan_decimal_number(++itr, --len) : node_type::INTEGER;
        default:
            return node_type::STRING;
        }
    }

    /// @brief Detects a scalar value type by scanning the contents right after the negative sign.
    /// @param itr The iterator to the past-the-negative-sign element of the scalar.
    /// @param len The length of the scalar contents left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_negative_number(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        if (is_digit(*itr)) {
            return (len > 1) ? scan_decimal_number(++itr, --len) : node_type::INTEGER;
        }

        if (*itr == '.') {
            // some integer(s) required after "-." as a floating point value.
            return (len > 1) ? scan_after_decimal_point(++itr, --len) : node_type::STRING;
        }

        return node_type::STRING;
    }

    /// @brief Detects a scalar value type by scanning the contents right after the beginning 0.
    /// @param itr The iterator to the past-the-zero element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_after_zero_at_first(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        if (is_digit(*itr)) {
            // a token consisting of the beginning '0' and some following numbers, e.g., `0123`, is not an integer
            // according to https://yaml.org/spec/1.2.2/#10213-integer.
            return node_type::STRING;
        }

        switch (*itr) {
        case '.':
            // 0 can be omitted after `0.`.
            return (len > 1) ? scan_after_decimal_point(++itr, --len) : node_type::FLOAT;
        case 'e':
        case 'E':
            // some integer(s) required after the exponent sign as a floating point value.
            return (len > 1) ? scan_after_exponent(++itr, --len) : node_type::STRING;
        case 'o':
            return (len > 1) ? scan_octal_number(++itr, --len) : node_type::STRING;
        case 'x':
            return (len > 1) ? scan_hexadecimal_number(++itr, --len) : node_type::STRING;
        default:
            return node_type::STRING;
        }
    }

    /// @brief Detects a scalar value type by scanning the contents part starting with a decimal.
    /// @param itr The iterator to the beginning decimal element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_decimal_number(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        if (is_digit(*itr)) {
            return (len > 1) ? scan_decimal_number(++itr, --len) : node_type::INTEGER;
        }

        switch (*itr) {
        case '.': {
            // 0 can be omitted after the decimal point
            return (len > 1) ? scan_after_decimal_point(++itr, --len) : node_type::FLOAT;
        }
        case 'e':
        case 'E':
            // some integer(s) required after the exponent
            return (len > 1) ? scan_after_exponent(++itr, --len) : node_type::STRING;
        default:
            return node_type::STRING;
        }
    }

    /// @brief Detects a scalar value type by scanning the contents right after a decimal point.
    /// @param itr The iterator to the past-the-decimal-point element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_after_decimal_point(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        for (uint32_t i = 0; i < len; i++) {
            const char c = *itr++;

            if (is_digit(c)) {
                continue;
            }

            if (c == 'e' || c == 'E') {
                if (i == len - 1) {
                    // some integer(s) required after the exponent
                    return node_type::STRING;
                }
                return scan_after_exponent(itr, len - i - 1);
            }

            return node_type::STRING;
        }

        return node_type::FLOAT;
    }

    /// @brief Detects a scalar value type by scanning the contents right after the exponent prefix ("e" or "E").
    /// @param itr The iterator to the past-the-exponent-prefix element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_after_exponent(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        const char c = *itr;
        if (c == '+' || c == '-') {
            if (len == 1) {
                // some integer(s) required after the sign.
                return node_type::STRING;
            }
            ++itr;
            --len;
        }

        for (uint32_t i = 0; i < len; i++) {
            if (!is_digit(*itr++)) {
                return node_type::STRING;
            }
        }

        return node_type::FLOAT;
    }

    /// @brief Detects a scalar value type by scanning the contents assuming octal numbers.
    /// @param itr The iterator to the octal-number element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_octal_number(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        switch (*itr) {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
            return (len > 1) ? scan_octal_number(++itr, --len) : node_type::INTEGER;
        default:
            return node_type::STRING;
        }
    }

    /// @brief Detects a scalar value type by scanning the contents assuming hexadecimal numbers.
    /// @param itr The iterator to the hexadecimal-number element of the scalar.
    /// @param len The length of the scalar left unscanned.
    /// @return A detected scalar value type.
    static node_type scan_hexadecimal_number(const char* itr, uint32_t len) noexcept {
        FK_YAML_ASSERT(len > 0);

        if (is_xdigit(*itr)) {
            return (len > 1) ? scan_hexadecimal_number(++itr, --len) : node_type::INTEGER;
        }
        return node_type::STRING;
    }

    /// @brief Check if the given character is a digit.
    /// @note This function is needed to avoid assertion failures in `std::isdigit()` especially when compiled with
    /// MSVC.
    /// @param c A character to be checked.
    /// @return true if the given character is a digit, false otherwise.
    static bool is_digit(char c) {
        return ('0' <= c && c <= '9');
    }

    /// @brief Check if the given character is a hex-digit.
    /// @note This function is needed to avoid assertion failures in `std::isxdigit()` especially when compiled with
    /// MSVC.
    /// @param c A character to be checked.
    /// @return true if the given character is a hex-digit, false otherwise.
    static bool is_xdigit(char c) {
        return (('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'));
    }
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_SCALAR_SCANNER_HPP */

// #include <fkYAML/detail/input/tag_t.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_TAG_T_HPP
#define FK_YAML_DETAIL_INPUT_TAG_T_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of YAML tag types.
enum class tag_t : std::uint8_t {
    NONE,            //!< Represents a non-specific tag "?".
    NON_SPECIFIC,    //!< Represents a non-specific tag "!".
    CUSTOM_TAG,      //!< Represents a custom tag
    SEQUENCE,        //!< Represents a sequence tag.
    MAPPING,         //!< Represents a mapping tag.
    NULL_VALUE,      //!< Represents a null value tag.
    BOOLEAN,         //!< Represents a boolean tag.
    INTEGER,         //!< Represents an integer type
    FLOATING_NUMBER, //!< Represents a floating point number tag.
    STRING,          //!< Represents a string tag.
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_TAG_T_HPP */

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/str_view.hpp>

// #include <fkYAML/detail/types/lexical_token_t.hpp>

// #include <fkYAML/exception.hpp>

// #include <fkYAML/node_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A parser for YAML scalars.
/// @tparam BasicNodeType A type of the container for parsed YAML scalars.
template <typename BasicNodeType>
class scalar_parser {
    static_assert(is_basic_node<BasicNodeType>::value, "scalar_parser only accepts basic_node<...>");

public:
    using basic_node_type = BasicNodeType;

private:
    /** A type for boolean node values. */
    using boolean_type = typename basic_node_type::boolean_type;
    /** A type for integer node values. */
    using integer_type = typename basic_node_type::integer_type;
    /** A type for floating point node values. */
    using float_number_type = typename basic_node_type::float_number_type;
    /** A type for string node values. */
    using string_type = typename basic_node_type::string_type;

public:
    /// @brief Constructs a new scalar_parser object.
    /// @param line Current line.
    /// @param indent Current indentation.
    scalar_parser(uint32_t line, uint32_t indent) noexcept
        : m_line(line),
          m_indent(indent) {
    }

    /// @brief Destroys a scalar_parser object.
    ~scalar_parser() noexcept = default;

    // std::string's copy constructor/assignment operator may throw a exception.
    scalar_parser(const scalar_parser&) = default;
    scalar_parser& operator=(const scalar_parser&) = default;

    scalar_parser(scalar_parser&&) noexcept = default;
    scalar_parser& operator=(scalar_parser&&) noexcept(std::is_nothrow_move_assignable<std::string>::value) = default;

    /// @brief Parses a token into a flow scalar (either plain, single quoted or double quoted)
    /// @param lex_type Lexical token type for the scalar.
    /// @param tag_type Tag type for the scalar.
    /// @param token Scalar contents.
    /// @return Parsed YAML flow scalar object.
    basic_node_type parse_flow(lexical_token_t lex_type, tag_t tag_type, str_view token) {
        FK_YAML_ASSERT(
            lex_type == lexical_token_t::PLAIN_SCALAR || lex_type == lexical_token_t::SINGLE_QUOTED_SCALAR ||
            lex_type == lexical_token_t::DOUBLE_QUOTED_SCALAR);
        FK_YAML_ASSERT(tag_type != tag_t::SEQUENCE && tag_type != tag_t::MAPPING);

        token = parse_flow_scalar_token(lex_type, token);
        const node_type value_type = decide_value_type(lex_type, tag_type, token);
        return create_scalar_node(value_type, tag_type, token);
    }

    /// @brief Parses a token into a block scalar (either literal or folded)
    /// @param lex_type Lexical token type for the scalar.
    /// @param tag_type Tag type for the scalar.
    /// @param token Scalar contents.
    /// @param header Block scalar header information.
    /// @return Parsed YAML block scalar object.
    basic_node_type parse_block(
        lexical_token_t lex_type, tag_t tag_type, str_view token, const block_scalar_header& header) {
        FK_YAML_ASSERT(
            lex_type == lexical_token_t::BLOCK_LITERAL_SCALAR || lex_type == lexical_token_t::BLOCK_FOLDED_SCALAR);
        FK_YAML_ASSERT(tag_type != tag_t::SEQUENCE && tag_type != tag_t::MAPPING);

        if (lex_type == lexical_token_t::BLOCK_LITERAL_SCALAR) {
            token = parse_block_literal_scalar(token, header);
        }
        else {
            token = parse_block_folded_scalar(token, header);
        }

        const node_type value_type = decide_value_type(lex_type, tag_type, token);
        return create_scalar_node(value_type, tag_type, token);
    }

private:
    /// @brief Parses a token into a flow scalar contents.
    /// @param lex_type Lexical token type for the scalar.
    /// @param token Scalar contents.
    /// @return View into the parsed scalar contents.
    str_view parse_flow_scalar_token(lexical_token_t lex_type, str_view token) {
        switch (lex_type) {
        case lexical_token_t::PLAIN_SCALAR:
            token = parse_plain_scalar(token);
            break;
        case lexical_token_t::SINGLE_QUOTED_SCALAR:
            token = parse_single_quoted_scalar(token);
            break;
        case lexical_token_t::DOUBLE_QUOTED_SCALAR:
            token = parse_double_quoted_scalar(token);
            break;
        default:           // LCOV_EXCL_LINE
            unreachable(); // LCOV_EXCL_LINE
        }

        return token;
    }

    /// @brief Parses plain scalar contents.
    /// @param token Scalar contents.
    /// @return View into the parsed scalar contents.
    str_view parse_plain_scalar(str_view token) noexcept {
        // plain scalars cannot be empty.
        FK_YAML_ASSERT(!token.empty());

        std::size_t newline_pos = token.find('\n');
        if (newline_pos == str_view::npos) {
            return token;
        }

        m_use_owned_buffer = true;

        if (m_buffer.capacity() < token.size()) {
            m_buffer.reserve(token.size());
        }

        do {
            process_line_folding(token, newline_pos);
            newline_pos = token.find('\n');
        } while (newline_pos != str_view::npos);

        m_buffer.append(token.begin(), token.size());

        return {m_buffer};
    }

    /// @brief Parses single quoted scalar contents.
    /// @param token Scalar contents.
    /// @return View into the parsed scalar contents.
    str_view parse_single_quoted_scalar(str_view token) noexcept {
        if (token.empty()) {
            return token;
        }

        constexpr str_view filter {"\'\n"};
        std::size_t pos = token.find_first_of(filter);
        if (pos == str_view::npos) {
            return token;
        }

        m_use_owned_buffer = true;

        if (m_buffer.capacity() < token.size()) {
            m_buffer.reserve(token.size());
        }

        do {
            FK_YAML_ASSERT(pos < token.size());
            FK_YAML_ASSERT(token[pos] == '\'' || token[pos] == '\n');

            if (token[pos] == '\'') {
                // unescape escaped single quote. ('' -> ')
                FK_YAML_ASSERT(pos + 1 < token.size());
                m_buffer.append(token.begin(), token.begin() + (pos + 1));
                token.remove_prefix(pos + 2); // move next to the escaped single quote.
            }
            else {
                process_line_folding(token, pos);
            }

            pos = token.find_first_of(filter);
        } while (pos != str_view::npos);

        if (!token.empty()) {
            m_buffer.append(token.begin(), token.size());
        }

        return {m_buffer};
    }

    /// @brief Parses double quoted scalar contents.
    /// @param token Scalar contents.
    /// @return View into the parsed scalar contents.
    str_view parse_double_quoted_scalar(str_view token) {
        if (token.empty()) {
            return token;
        }

        constexpr str_view filter {"\\\n"};
        std::size_t pos = token.find_first_of(filter);
        if (pos == str_view::npos) {
            return token;
        }

        m_use_owned_buffer = true;

        if (m_buffer.capacity() < token.size()) {
            m_buffer.reserve(token.size());
        }

        do {
            FK_YAML_ASSERT(pos < token.size());
            FK_YAML_ASSERT(token[pos] == '\\' || token[pos] == '\n');

            if (token[pos] == '\\') {
                FK_YAML_ASSERT(pos + 1 < token.size());
                m_buffer.append(token.begin(), token.begin() + pos);

                if (token[pos + 1] != '\n') {
                    token.remove_prefix(pos);
                    const char* p_escape_begin = token.begin();
                    const bool is_valid_escaping = yaml_escaper::unescape(p_escape_begin, token.end(), m_buffer);
                    if FK_YAML_UNLIKELY (!is_valid_escaping) {
                        throw parse_error(
                            "Unsupported escape sequence is found in a double quoted scalar.", m_line, m_indent);
                    }

                    // `p_escape_begin` points to the last element of the escape sequence.
                    token.remove_prefix((p_escape_begin - token.begin()) + 1);
                }
                else {
                    std::size_t non_space_pos = token.find_first_not_of(" \t", pos + 2);
                    if (non_space_pos == str_view::npos) {
                        non_space_pos = token.size();
                    }
                    token.remove_prefix(non_space_pos);
                }
            }
            else {
                process_line_folding(token, pos);
            }

            pos = token.find_first_of(filter);
        } while (pos != str_view::npos);

        if (!token.empty()) {
            m_buffer.append(token.begin(), token.size());
        }

        return {m_buffer};
    }

    /// @brief Parses block literal scalar contents.
    /// @param token Scalar contents.
    /// @param header Block scalar header information.
    /// @return View into the parsed scalar contents.
    str_view parse_block_literal_scalar(str_view token, const block_scalar_header& header) {
        if FK_YAML_UNLIKELY (token.empty()) {
            return token;
        }

        m_use_owned_buffer = true;
        m_buffer.reserve(token.size());

        std::size_t cur_line_begin_pos = 0;
        do {
            bool has_newline_at_end = true;
            std::size_t cur_line_end_pos = token.find('\n', cur_line_begin_pos);
            if (cur_line_end_pos == str_view::npos) {
                has_newline_at_end = false;
                cur_line_end_pos = token.size();
            }

            const std::size_t line_size = cur_line_end_pos - cur_line_begin_pos;
            const str_view line = token.substr(cur_line_begin_pos, line_size);

            if (line.size() > header.indent) {
                m_buffer.append(line.begin() + header.indent, line.end());
            }

            if (!has_newline_at_end) {
                break;
            }

            m_buffer.push_back('\n');
            cur_line_begin_pos = cur_line_end_pos + 1;
        } while (cur_line_begin_pos < token.size());

        process_chomping(header.chomp);

        return {m_buffer};
    }

    /// @brief Parses block folded scalar contents.
    /// @param token Scalar contents.
    /// @param header Block scalar header information.
    /// @return View into the parsed scalar contents.
    str_view parse_block_folded_scalar(str_view token, const block_scalar_header& header) {
        if FK_YAML_UNLIKELY (token.empty()) {
            return token;
        }

        m_use_owned_buffer = true;
        m_buffer.reserve(token.size());

        constexpr str_view white_space_filter {" \t"};

        std::size_t cur_line_begin_pos = 0;
        bool has_newline_at_end = true;
        bool can_be_folded = false;
        do {
            std::size_t cur_line_end_pos = token.find('\n', cur_line_begin_pos);
            if (cur_line_end_pos == str_view::npos) {
                has_newline_at_end = false;
                cur_line_end_pos = token.size();
            }

            const std::size_t line_size = cur_line_end_pos - cur_line_begin_pos;
            const str_view line = token.substr(cur_line_begin_pos, line_size);
            const bool is_empty = line.find_first_not_of(white_space_filter) == str_view::npos;

            if (line.size() <= header.indent) {
                // A less-indented line is turned into a newline.
                m_buffer.push_back('\n');
                can_be_folded = false;
            }
            else if (is_empty) {
                // more-indented empty lines are not folded.
                m_buffer.push_back('\n');
                m_buffer.append(line.begin() + header.indent, line.end());
                m_buffer.push_back('\n');
            }
            else {
                const std::size_t non_space_pos = line.find_first_not_of(white_space_filter);
                const bool is_more_indented = (non_space_pos != str_view::npos) && (non_space_pos > header.indent);

                if (can_be_folded) {
                    if (is_more_indented) {
                        // The content line right before more-indented lines is not folded.
                        m_buffer.push_back('\n');
                    }
                    else {
                        m_buffer.push_back(' ');
                    }

                    can_be_folded = false;
                }

                m_buffer.append(line.begin() + header.indent, line.end());

                if (is_more_indented && has_newline_at_end) {
                    // more-indented lines are not folded.
                    m_buffer.push_back('\n');
                }
                else {
                    can_be_folded = true;
                }
            }

            if (!has_newline_at_end) {
                break;
            }

            cur_line_begin_pos = cur_line_end_pos + 1;
        } while (cur_line_begin_pos < token.size());

        if (has_newline_at_end && can_be_folded) {
            // The final content line break are not folded.
            m_buffer.push_back('\n');
        }

        process_chomping(header.chomp);

        return {m_buffer};
    }

    /// @brief Discards final content line break and trailing empty lines depending on the given chomping type.
    /// @param chomp Chomping method type.
    void process_chomping(chomping_indicator_t chomp) {
        switch (chomp) {
        case chomping_indicator_t::STRIP: {
            const std::size_t content_end_pos = m_buffer.find_last_not_of('\n');
            if (content_end_pos == std::string::npos) {
                // if the scalar has no content line, all lines are considered as trailing empty lines.
                m_buffer.clear();
                break;
            }

            if (content_end_pos == m_buffer.size() - 1) {
                // no last content line break nor trailing empty lines.
                break;
            }

            // remove the last content line break and all trailing empty lines.
            m_buffer.erase(content_end_pos + 1);

            break;
        }
        case chomping_indicator_t::CLIP: {
            const std::size_t content_end_pos = m_buffer.find_last_not_of('\n');
            if (content_end_pos == std::string::npos) {
                // if the scalar has no content line, all lines are considered as trailing empty lines.
                m_buffer.clear();
                break;
            }

            if (content_end_pos == m_buffer.size() - 1) {
                // no trailing empty lines
                break;
            }

            // remove all trailing empty lines.
            m_buffer.erase(content_end_pos + 2);

            break;
        }
        case chomping_indicator_t::KEEP:
            break;
        }
    }

    /// @brief Applies line folding to flow scalar contents.
    /// @param token Flow scalar contents.
    /// @param newline_pos Position of the target newline code.
    void process_line_folding(str_view& token, std::size_t newline_pos) noexcept {
        // discard trailing white spaces which precedes the line break in the current line.
        const std::size_t last_non_space_pos = token.substr(0, newline_pos + 1).find_last_not_of(" \t");
        if (last_non_space_pos == str_view::npos) {
            m_buffer.append(token.begin(), newline_pos);
        }
        else {
            m_buffer.append(token.begin(), last_non_space_pos + 1);
        }
        token.remove_prefix(newline_pos + 1); // move next to the LF

        uint32_t empty_line_counts = 0;
        do {
            const std::size_t non_space_pos = token.find_first_not_of(" \t");
            if (non_space_pos == str_view::npos) {
                // Line folding ignores trailing spaces.
                token.remove_prefix(token.size());
                break;
            }
            if (token[non_space_pos] != '\n') {
                token.remove_prefix(non_space_pos);
                break;
            }

            token.remove_prefix(non_space_pos + 1);
            ++empty_line_counts;
        } while (true);

        if (empty_line_counts > 0) {
            m_buffer.append(empty_line_counts, '\n');
        }
        else {
            m_buffer.push_back(' ');
        }
    }

    /// @brief Decides scalar value type based on the lexical/tag types and scalar contents.
    /// @param lex_type Lexical token type for the scalar.
    /// @param tag_type Tag type for the scalar.
    /// @param token Scalar contents.
    /// @return Scalar value type.
    node_type decide_value_type(lexical_token_t lex_type, tag_t tag_type, str_view token) const noexcept {
        node_type value_type {node_type::STRING};
        if (lex_type == lexical_token_t::PLAIN_SCALAR) {
            value_type = scalar_scanner::scan(token.begin(), token.end());
        }

        switch (tag_type) {
        case tag_t::NULL_VALUE:
            value_type = node_type::NULL_OBJECT;
            break;
        case tag_t::BOOLEAN:
            value_type = node_type::BOOLEAN;
            break;
        case tag_t::INTEGER:
            value_type = node_type::INTEGER;
            break;
        case tag_t::FLOATING_NUMBER:
            value_type = node_type::FLOAT;
            break;
        case tag_t::STRING:
        case tag_t::NON_SPECIFIC:
            // scalars with the non-specific tag is resolved to a string tag.
            // See the "Non-Specific Tags" section in https://yaml.org/spec/1.2.2/#691-node-tags.
            value_type = node_type::STRING;
            break;
        case tag_t::NONE:
        case tag_t::CUSTOM_TAG:
        default:
            break;
        }

        return value_type;
    }

    /// @brief Creates YAML scalar object based on the value type and contents.
    /// @param type Scalar value type.
    /// @param token Scalar contents.
    /// @return A YAML scalar object.
    basic_node_type create_scalar_node(node_type val_type, tag_t tag_type, str_view token) {
        switch (val_type) {
        case node_type::NULL_OBJECT: {
            std::nullptr_t null = nullptr;
            const bool converted = detail::aton(token.begin(), token.end(), null);
            if FK_YAML_UNLIKELY (!converted) {
                throw parse_error("Failed to convert a scalar to a null.", m_line, m_indent);
            }
            // The default basic_node object is a null scalar node.
            return basic_node_type {};
        }
        case node_type::BOOLEAN: {
            auto boolean = static_cast<boolean_type>(false);
            const bool converted = detail::atob(token.begin(), token.end(), boolean);
            if FK_YAML_UNLIKELY (!converted) {
                throw parse_error("Failed to convert a scalar to a boolean.", m_line, m_indent);
            }
            return basic_node_type(boolean);
        }
        case node_type::INTEGER: {
            integer_type integer = 0;
            const bool converted = detail::atoi(token.begin(), token.end(), integer);
            if FK_YAML_LIKELY (converted) {
                return basic_node_type(integer);
            }
            if FK_YAML_UNLIKELY (tag_type == tag_t::INTEGER) {
                throw parse_error("Failed to convert a scalar to an integer.", m_line, m_indent);
            }

            // conversion error from a scalar which is not tagged with !!int is recovered by treating it as a string
            // scalar. See https://github.com/fktn-k/fkYAML/issues/428.
            return basic_node_type(string_type(token.begin(), token.end()));
        }
        case node_type::FLOAT: {
            float_number_type float_val = 0;
            const bool converted = detail::atof(token.begin(), token.end(), float_val);
            if FK_YAML_LIKELY (converted) {
                return basic_node_type(float_val);
            }
            if FK_YAML_UNLIKELY (tag_type == tag_t::FLOATING_NUMBER) {
                throw parse_error("Failed to convert a scalar to a floating point value", m_line, m_indent);
            }

            // conversion error from a scalar which is not tagged with !!float is recovered by treating it as a string
            // scalar. See https://github.com/fktn-k/fkYAML/issues/428.
            return basic_node_type(string_type(token.begin(), token.end()));
        }
        case node_type::STRING:
            if (!m_use_owned_buffer) {
                return basic_node_type(string_type(token.begin(), token.end()));
            }
            m_use_owned_buffer = false;
            return basic_node_type(std::move(m_buffer));
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }
    }

    /// Current line
    uint32_t m_line {0};
    /// Current indentation for the scalar
    uint32_t m_indent {0};
    /// Whether the parsed contents are stored in an owned buffer.
    bool m_use_owned_buffer {false};
    /// Owned buffer storage for parsing. This buffer is used when scalar contents need mutation.
    std::string m_buffer;
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_SCALAR_PARSER_HPP */

// #include <fkYAML/detail/input/tag_resolver.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_TAG_RESOLVER_HPP
#define FK_YAML_DETAIL_INPUT_TAG_RESOLVER_HPP

#include <memory>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/detail/document_metainfo.hpp>

// #include <fkYAML/detail/input/tag_t.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/str_view.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

static constexpr str_view default_primary_handle_prefix {"!"};
static constexpr str_view default_secondary_handle_prefix {"tag:yaml.org,2002:"};

template <typename BasicNodeType>
class tag_resolver {
    static_assert(is_basic_node<BasicNodeType>::value, "tag_resolver only accepts basic_node<...>.");
    using doc_metainfo_type = document_metainfo<BasicNodeType>;

public:
    /// @brief Resolve the input tag name into an expanded tag name prepended with a registered prefix.
    /// @param tag The input tag name.
    /// @return The type of a node deduced from the given tag name.
    static tag_t resolve_tag(const str_view tag, const std::shared_ptr<doc_metainfo_type>& directives) {
        const std::string normalized = normalize_tag_name(tag, directives);
        return convert_to_tag_type(normalized);
    }

private:
    static std::string normalize_tag_name(const str_view tag, const std::shared_ptr<doc_metainfo_type>& directives) {
        if FK_YAML_UNLIKELY (tag.empty()) {
            throw invalid_tag("tag must not be empty.", "");
        }
        if FK_YAML_UNLIKELY (tag[0] != '!') {
            throw invalid_tag("tag must start with \'!\'", std::string(tag.begin(), tag.end()).c_str());
        }

        if (tag.size() == 1) {
            // Non-specific tag ("!") will be interpreted as one of the following:
            //   * tag:yaml.org,2002:seq
            //   * tag:yaml.org,2002:map
            //   * tag:yaml.org,2002:str
            // See the "Non-Specific Tags" section in https://yaml.org/spec/1.2.2/#691-node-tags.
            // The interpretation cannot take place here because the input lacks the corresponding value.
            return {tag.begin(), tag.end()};
        }

        std::string normalized {"!<"};
        switch (tag[1]) {
        case '!': {
            // handle a secondary tag handle (!!suffix -> !<[secondary][suffix]>)
            const bool is_null_or_empty = !directives || directives->secondary_handle_prefix.empty();
            if (is_null_or_empty) {
                normalized.append(default_secondary_handle_prefix.begin(), default_secondary_handle_prefix.end());
            }
            else {
                normalized += directives->secondary_handle_prefix;
            }

            const str_view body = tag.substr(2);
            normalized.append(body.begin(), body.end());
            break;
        }
        case '<':
            if (tag[2] == '!') {
                const bool is_null_or_empty = !directives || directives->primary_handle_prefix.empty();
                if (is_null_or_empty) {
                    normalized.append(default_primary_handle_prefix.begin(), default_primary_handle_prefix.end());
                }
                else {
                    normalized += directives->primary_handle_prefix;
                }

                const str_view body = tag.substr(3);
                return normalized.append(body.begin(), body.end());
            }

            // verbatim tags must be delivered as-is to the application.
            // See https://yaml.org/spec/1.2.2/#691-node-tags for more details.
            return {tag.begin(), tag.end()};
        default: {
            const std::size_t tag_end_pos = tag.find_first_of('!', 1);

            // handle a named handle (!tag!suffix -> !<[tag][suffix]>)
            if (tag_end_pos != std::string::npos) {
                // there must be a non-empty suffix. (already checked by the lexer.)
                FK_YAML_ASSERT(tag_end_pos < tag.size() - 1);

                const bool is_null_or_empty = !directives || directives->named_handle_map.empty();
                if FK_YAML_UNLIKELY (is_null_or_empty) {
                    throw invalid_tag(
                        "named handle has not been registered.", std::string(tag.begin(), tag.end()).c_str());
                }

                // find the extracted named handle in the map.
                const str_view named_handle = tag.substr(0, tag_end_pos + 1);
                auto named_handle_itr = directives->named_handle_map.find({named_handle.begin(), named_handle.end()});
                auto end_itr = directives->named_handle_map.end();
                if FK_YAML_UNLIKELY (named_handle_itr == end_itr) {
                    throw invalid_tag(
                        "named handle has not been registered.", std::string(tag.begin(), tag.end()).c_str());
                }

                // The YAML spec prohibits expanding the percent-encoded characters (%xx -> a UTF-8 byte).
                // So no conversion takes place.
                // See https://yaml.org/spec/1.2.2/#56-miscellaneous-characters for more details.

                normalized += named_handle_itr->second;
                const str_view body = tag.substr(tag_end_pos + 1);
                normalized.append(body.begin(), body.end());
                break;
            }

            // handle a primary tag handle (!suffix -> !<[primary][suffix]>)
            const bool is_null_or_empty = !directives || directives->primary_handle_prefix.empty();
            if (is_null_or_empty) {
                normalized.append(default_primary_handle_prefix.begin(), default_primary_handle_prefix.end());
            }
            else {
                normalized += directives->primary_handle_prefix;
            }

            const str_view body = tag.substr(1);
            normalized.append(body.begin(), body.end());
            break;
        }
        }

        normalized += ">";
        return normalized;
    }

    static tag_t convert_to_tag_type(const std::string& normalized) {
        if (normalized == "!") {
            return tag_t::NON_SPECIFIC;
        }

        if (normalized.size() < 24 /* size of !<tag:yaml.org,2002:xxx */) {
            return tag_t::CUSTOM_TAG;
        }
        if (normalized.rfind("!<tag:yaml.org,2002:", 0) == std::string::npos) {
            return tag_t::CUSTOM_TAG;
        }

        if (normalized == "!<tag:yaml.org,2002:seq>") {
            return tag_t::SEQUENCE;
        }
        if (normalized == "!<tag:yaml.org,2002:map>") {
            return tag_t::MAPPING;
        }
        if (normalized == "!<tag:yaml.org,2002:null>") {
            return tag_t::NULL_VALUE;
        }
        if (normalized == "!<tag:yaml.org,2002:bool>") {
            return tag_t::BOOLEAN;
        }
        if (normalized == "!<tag:yaml.org,2002:int>") {
            return tag_t::INTEGER;
        }
        if (normalized == "!<tag:yaml.org,2002:float>") {
            return tag_t::FLOATING_NUMBER;
        }
        if (normalized == "!<tag:yaml.org,2002:str>") {
            return tag_t::STRING;
        }

        return tag_t::CUSTOM_TAG;
    }
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_TAG_RESOLVER_HPP */

// #include <fkYAML/detail/meta/input_adapter_traits.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_META_INPUT_ADAPTER_TRAITS_HPP
#define FK_YAML_DETAIL_META_INPUT_ADAPTER_TRAITS_HPP

#include <type_traits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/detect.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

///////////////////////////////////////////
//   Input Adapter API detection traits
///////////////////////////////////////////

/// @brief A type which represents get_buffer_view function.
/// @tparam T A target type.
template <typename T>
using get_buffer_view_fn_t = decltype(std::declval<T>().get_buffer_view());

/// @brief Type traits to check if InputAdapterType has get_buffer_view member function.
/// @tparam InputAdapterType An input adapter type to check if it has get_buffer_view function.
/// @tparam typename N/A
template <typename InputAdapterType>
using has_get_buffer_view = is_detected<get_buffer_view_fn_t, InputAdapterType>;

////////////////////////////////
//   is_input_adapter traits
////////////////////////////////

/// @brief Type traits to check if T is an input adapter type.
/// @tparam T A target type.
/// @tparam typename N/A
template <typename T, typename = void>
struct is_input_adapter : std::false_type {};

/// @brief A partial specialization of is_input_adapter if T is an input adapter type.
/// @tparam InputAdapterType
template <typename InputAdapterType>
struct is_input_adapter<InputAdapterType, enable_if_t<has_get_buffer_view<InputAdapterType>::value>> : std::true_type {
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_META_INPUT_ADAPTER_TRAITS_HPP */

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/node_attrs.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_NODE_ATTRS_HPP
#define FK_YAML_DETAIL_NODE_ATTRS_HPP

#include <cstdint>
#include <limits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/node_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief The type for node attribute bits.
using node_attr_t = uint32_t;

/// @brief The namespace to define bit masks for node attribute bits.
namespace node_attr_mask {

/// The bit mask for node value type bits.
constexpr node_attr_t value = 0x0000FFFFu;
/// The bit mask for node style type bits. (bits are not yet defined.)
constexpr node_attr_t style = 0x00FF0000u;
/// The bit mask for node property related bits.
constexpr node_attr_t props = 0xFF000000u;
/// The bit mask for anchor/alias node type bits.
constexpr node_attr_t anchoring = 0x03000000u;
/// The bit mask for anchor offset value bits.
constexpr node_attr_t anchor_offset = 0xFC000000u;
/// The bit mask for all the bits for node attributes.
constexpr node_attr_t all = std::numeric_limits<node_attr_t>::max();

} // namespace node_attr_mask

/// @brief The namespace to define bits for node attributes.
namespace node_attr_bits {

/// The sequence node bit.
constexpr node_attr_t seq_bit = 1u << 0;
/// The mapping node bit.
constexpr node_attr_t map_bit = 1u << 1;
/// The null scalar node bit.
constexpr node_attr_t null_bit = 1u << 2;
/// The boolean scalar node bit.
constexpr node_attr_t bool_bit = 1u << 3;
/// The integer scalar node bit.
constexpr node_attr_t int_bit = 1u << 4;
/// The floating point scalar node bit.
constexpr node_attr_t float_bit = 1u << 5;
/// The string scalar node bit.
constexpr node_attr_t string_bit = 1u << 6;

/// A utility bit set to filter scalar node bits.
constexpr node_attr_t scalar_bits = null_bit | bool_bit | int_bit | float_bit | string_bit;

/// The anchor node bit.
constexpr node_attr_t anchor_bit = 0x01000000u;
/// The alias node bit.
constexpr node_attr_t alias_bit = 0x02000000u;

/// A utility bit set for initialization.
constexpr node_attr_t default_bits = null_bit;

/// @brief Converts a node_type value to a node_attr_t value.
/// @param t A type of node value.
/// @return The associated node value bit.
inline node_attr_t from_node_type(node_type t) noexcept {
    switch (t) {
    case node_type::SEQUENCE:
        return seq_bit;
    case node_type::MAPPING:
        return map_bit;
    case node_type::NULL_OBJECT:
        return null_bit;
    case node_type::BOOLEAN:
        return bool_bit;
    case node_type::INTEGER:
        return int_bit;
    case node_type::FLOAT:
        return float_bit;
    case node_type::STRING:
        return string_bit;
    default:                        // LCOV_EXCL_LINE
        return node_attr_mask::all; // LCOV_EXCL_LINE
    }
}

/// @brief Converts a node_attr_t value to a node_type value.
/// @param bits node attribute bits
/// @return An associated node value type with the given node value bit.
inline node_type to_node_type(node_attr_t bits) noexcept {
    switch (bits & node_attr_mask::value) {
    case seq_bit:
        return node_type::SEQUENCE;
    case map_bit:
        return node_type::MAPPING;
    case null_bit:
        return node_type::NULL_OBJECT;
    case bool_bit:
        return node_type::BOOLEAN;
    case int_bit:
        return node_type::INTEGER;
    case float_bit:
        return node_type::FLOAT;
    case string_bit:
        return node_type::STRING;
    default:                   // LCOV_EXCL_LINE
        detail::unreachable(); // LCOV_EXCL_LINE
    }
}

/// @brief Get an anchor offset used to reference an anchor node from the given attribute bits.
/// @param attrs node attribute bits
/// @return An anchor offset value.
inline uint32_t get_anchor_offset(node_attr_t attrs) noexcept {
    return (attrs & node_attr_mask::anchor_offset) >> 26;
}

/// @brief Set an anchor offset value to the appropriate bits.
/// @param offset An anchor offset value.
/// @param attrs node attribute bit set into which the offset value is written.
inline void set_anchor_offset(uint32_t offset, node_attr_t& attrs) noexcept {
    attrs &= ~node_attr_mask::anchor_offset;
    attrs |= (offset & 0x3Fu) << 26;
}

} // namespace node_attr_bits

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_NODE_ATTRS_HPP */

// #include <fkYAML/detail/node_property.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_NODE_PROPERTY_HPP
#define FK_YAML_DETAIL_NODE_PROPERTY_HPP

#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

struct node_property {
    /// The tag name property.
    std::string tag {}; // NOLINT(readability-redundant-member-init) necessary for older compilers
    /// The anchor name property.
    std::string anchor {}; // NOLINT(readability-redundant-member-init) necessary for older compilers
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_NODE_PROPERTY_HPP */

// #include <fkYAML/detail/types/lexical_token_t.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A class which provides the feature of deserializing YAML documents.
/// @tparam BasicNodeType A type of the container for deserialized YAML values.
template <typename BasicNodeType>
class basic_deserializer {
    static_assert(is_basic_node<BasicNodeType>::value, "basic_deserializer only accepts basic_node<...>");

    /** A type for the target basic_node. */
    using basic_node_type = BasicNodeType;
    /** A type for the lexical analyzer. */
    using lexer_type = lexical_analyzer;
    /** A type for the document metainfo. */
    using doc_metainfo_type = document_metainfo<basic_node_type>;
    /** A type for the tag resolver. */
    using tag_resolver_type = tag_resolver<basic_node_type>;
    /** A type for the scalar parser. */
    using scalar_parser_type = scalar_parser<basic_node_type>;
    /** A type for sequence node value containers. */
    using sequence_type = typename basic_node_type::sequence_type;
    /** A type for mapping node value containers. */
    using mapping_type = typename basic_node_type::mapping_type;

    /// @brief Definition of state types of parse contexts.
    enum class context_state_t : std::uint8_t {
        BLOCK_MAPPING,                //!< The underlying node is a block mapping.
        BLOCK_MAPPING_EXPLICIT_KEY,   //!< The underlying node is an explicit block mapping key.
        BLOCK_MAPPING_EXPLICIT_VALUE, //!< The underlying node is an explicit block mapping value.
        MAPPING_VALUE,                //!< The underlying node is a block mapping value.
        BLOCK_SEQUENCE,               //!< The underlying node is a block sequence.
        BLOCK_SEQUENCE_ENTRY,         //!< The underlying node is a block sequence entry.
        FLOW_SEQUENCE,                //!< The underlying node is a flow sequence.
        FLOW_SEQUENCE_KEY,            //!< The underlying node is a flow sequence as a key.
        FLOW_MAPPING,                 //!< The underlying node is a flow mapping.
        FLOW_MAPPING_KEY,             //!< The underlying node is a flow mapping as a key.
    };

    /// @brief Context information set for parsing.
    struct parse_context {
        /// @brief Construct a new parse_context object.
        parse_context() = default;

        /// @brief Construct a new parse_context object with non-default values for each parameter.
        /// @param line The current line. (count from zero)
        /// @param indent The indentation width in the current line. (count from zero)
        /// @param state The parse context type.
        /// @param p_node The underlying node associated to this context.
        parse_context(uint32_t line, uint32_t indent, context_state_t state, basic_node_type* p_node) noexcept
            : line(line),
              indent(indent),
              state(state),
              p_node(p_node) {
        }

        parse_context(const parse_context&) noexcept = default;
        parse_context& operator=(const parse_context&) noexcept = default;
        parse_context(parse_context&&) noexcept = default;
        parse_context& operator=(parse_context&&) noexcept = default;

        ~parse_context() {
            switch (state) {
            case context_state_t::BLOCK_MAPPING_EXPLICIT_KEY:
            case context_state_t::FLOW_SEQUENCE_KEY:
            case context_state_t::FLOW_MAPPING_KEY:
                delete p_node;
                p_node = nullptr;
                break;
            default:
                break;
            }
        }

        /// The current line. (count from zero)
        uint32_t line {0};
        /// The indentation width in the current line. (count from zero)
        uint32_t indent {0};
        /// The parse context type.
        context_state_t state {context_state_t::BLOCK_MAPPING};
        /// The pointer to the associated node to this context.
        basic_node_type* p_node {nullptr};
    };

    /// @brief Definitions of state types for expected flow token hints.
    enum class flow_token_state_t : std::uint8_t {
        NEEDS_VALUE_OR_SUFFIX,     //!< Either value or flow suffix (`]` or `}`)
        NEEDS_SEPARATOR_OR_SUFFIX, //!< Either separator (`,`) or flow suffix (`]` or `}`)
    };

public:
    /// @brief Construct a new basic_deserializer object.
    basic_deserializer() = default;

public:
    /// @brief Deserialize a single YAML document into a YAML node.
    /// @note
    /// If the input consists of multiple YAML documents, this function only parses the first.
    /// If the input may have multiple YAML documents all of which must be parsed into nodes,
    /// prefer the `deserialize_docs()` function.
    /// @tparam InputAdapterType The type of an input adapter object.
    /// @param input_adapter An input adapter object for the input source buffer.
    /// @return basic_node_type A root YAML node deserialized from the source string.
    template <typename InputAdapterType, enable_if_t<is_input_adapter<InputAdapterType>::value, int> = 0>
    basic_node_type deserialize(InputAdapterType&& input_adapter) { // NOLINT(cppcoreguidelines-missing-std-forward)
        const str_view input_view = input_adapter.get_buffer_view();
        lexer_type lexer(input_view);

        lexical_token_t type {lexical_token_t::END_OF_BUFFER};
        return deserialize_document(lexer, type);
    }

    /// @brief Deserialize multiple YAML documents into YAML nodes.
    /// @tparam InputAdapterType The type of an adapter object.
    /// @param input_adapter An input adapter object for the input source buffer.
    /// @return std::vector<basic_node_type> Root YAML nodes for deserialized YAML documents.
    template <typename InputAdapterType, enable_if_t<is_input_adapter<InputAdapterType>::value, int> = 0>
    // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
    std::vector<basic_node_type> deserialize_docs(InputAdapterType&& input_adapter) {
        const str_view input_view = input_adapter.get_buffer_view();
        lexer_type lexer(input_view);

        std::vector<basic_node_type> nodes {};
        lexical_token_t type {lexical_token_t::END_OF_BUFFER};

        do {
            nodes.emplace_back(deserialize_document(lexer, type));
        } while (type != lexical_token_t::END_OF_BUFFER);

        return nodes;
    } // LCOV_EXCL_LINE

private:
    /// @brief Deserialize a YAML document into a YAML node.
    /// @param lexer The lexical analyzer to be used.
    /// @param last_type The variable to store the last lexical token type.
    /// @return basic_node_type A root YAML node deserialized from the YAML document.
    basic_node_type deserialize_document(lexer_type& lexer, lexical_token_t& last_type) {
        lexical_token token {};

        basic_node_type root;
        mp_current_node = &root;
        mp_meta = root.mp_meta;

        // parse directives first.
        deserialize_directives(lexer, token);

        // parse node properties for root node if any
        uint32_t line = lexer.get_lines_processed();
        uint32_t indent = lexer.get_last_token_begin_pos();
        const bool found_props = deserialize_node_properties(lexer, token, line, indent);

        switch (token.type) {
        case lexical_token_t::SEQUENCE_BLOCK_PREFIX: {
            root = basic_node_type::sequence({basic_node_type()});
            apply_directive_set(root);
            if (found_props) {
                // If node properties are found before the block sequence entry prefix, the properties belong to the
                // root sequence node.
                apply_node_properties(root);
            }

            parse_context context(
                lexer.get_lines_processed(), lexer.get_last_token_begin_pos(), context_state_t::BLOCK_SEQUENCE, &root);
            m_context_stack.emplace_back(context);

            mp_current_node = &(root.as_seq().back());
            apply_directive_set(*mp_current_node);
            context.state = context_state_t::BLOCK_SEQUENCE_ENTRY;
            context.p_node = mp_current_node;
            m_context_stack.emplace_back(std::move(context));

            token = lexer.get_next_token();
            line = lexer.get_lines_processed();
            indent = lexer.get_last_token_begin_pos();
            break;
        }
        case lexical_token_t::SEQUENCE_FLOW_BEGIN:
            ++m_flow_context_depth;
            lexer.set_context_state(true);
            root = basic_node_type::sequence();
            apply_directive_set(root);
            apply_node_properties(root);
            m_context_stack.emplace_back(
                lexer.get_lines_processed(), lexer.get_last_token_begin_pos(), context_state_t::FLOW_SEQUENCE, &root);
            token = lexer.get_next_token();
            line = lexer.get_lines_processed();
            indent = lexer.get_last_token_begin_pos();
            break;
        case lexical_token_t::MAPPING_FLOW_BEGIN:
            ++m_flow_context_depth;
            lexer.set_context_state(true);
            root = basic_node_type::mapping();
            apply_directive_set(root);
            apply_node_properties(root);
            m_context_stack.emplace_back(
                lexer.get_lines_processed(), lexer.get_last_token_begin_pos(), context_state_t::FLOW_MAPPING, &root);
            token = lexer.get_next_token();
            line = lexer.get_lines_processed();
            indent = lexer.get_last_token_begin_pos();
            break;
        case lexical_token_t::EXPLICIT_KEY_PREFIX: {
            // If the explicit key prefix (? ) is detected here, the root node of current document must be a mapping.
            // Also, tag and anchor if any are associated to the root mapping node.
            // No get_next_token() call here to handle the token event in the deserialize_node() function.
            root = basic_node_type::mapping();
            apply_directive_set(root);
            apply_node_properties(root);
            parse_context context(
                lexer.get_lines_processed(), lexer.get_last_token_begin_pos(), context_state_t::BLOCK_MAPPING, &root);
            m_context_stack.emplace_back(std::move(context));
            line = lexer.get_lines_processed();
            indent = lexer.get_last_token_begin_pos();
            break;
        }
        case lexical_token_t::BLOCK_LITERAL_SCALAR:
        case lexical_token_t::BLOCK_FOLDED_SCALAR:
            // If a block scalar token is detected here, current document contains single scalar.
            // Do nothing here since the token is handled in the deserialize_node() function.
            break;
        case lexical_token_t::PLAIN_SCALAR:
        case lexical_token_t::SINGLE_QUOTED_SCALAR:
        case lexical_token_t::DOUBLE_QUOTED_SCALAR:
        case lexical_token_t::ALIAS_PREFIX:
            // Defer handling the above token events until the next call on the deserialize_scalar() function since the
            // meaning depends on subsequent events.
            if (found_props && line < lexer.get_lines_processed()) {
                // If node properties and a followed node are on the different line, the properties belong to the root
                // node.
                if (m_needs_anchor_impl) {
                    m_root_anchor_name = m_anchor_name;
                    m_needs_anchor_impl = false;
                    m_anchor_name = {};
                }

                if (m_needs_tag_impl) {
                    m_root_tag_name = m_tag_name;
                    m_needs_tag_impl = false;
                    m_tag_name = {};
                }

                line = lexer.get_lines_processed();
                indent = lexer.get_last_token_begin_pos();
            }
            break;
        default:
            // Do nothing since current document has no contents.
            break;
        }

        // parse YAML nodes recursively
        deserialize_node(lexer, token, line, indent, last_type);
        FK_YAML_ASSERT(
            last_type == lexical_token_t::END_OF_BUFFER || last_type == lexical_token_t::END_OF_DIRECTIVES ||
            last_type == lexical_token_t::END_OF_DOCUMENT);

        // reset parameters for the next call.
        mp_current_node = nullptr;
        mp_meta.reset();
        m_needs_tag_impl = false;
        m_needs_anchor_impl = false;
        m_flow_context_depth = 0;
        m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;
        m_context_stack.clear();

        return root;
    }

    /// @brief Deserializes the YAML directives if specified.
    /// @param lexer The lexical analyzer to be used.
    /// @param last_token Storage for last lexical token type.
    void deserialize_directives(lexer_type& lexer, lexical_token& last_token) {
        bool lacks_end_of_directives_marker = false;
        lexer.set_document_state(true);

        for (;;) {
            const lexical_token token = lexer.get_next_token();

            switch (token.type) {
            case lexical_token_t::YAML_VER_DIRECTIVE:
                if FK_YAML_UNLIKELY (mp_meta->is_version_specified) {
                    throw parse_error(
                        "YAML version cannot be specified more than once.",
                        lexer.get_lines_processed(),
                        lexer.get_last_token_begin_pos());
                }

                mp_meta->version = convert_yaml_version(lexer.get_yaml_version());
                mp_meta->is_version_specified = true;
                lacks_end_of_directives_marker = true;
                break;
            case lexical_token_t::TAG_DIRECTIVE: {
                const str_view tag_handle_view = lexer.get_tag_handle();
                switch (tag_handle_view.size()) {
                case 1 /* ! */: {
                    const bool is_already_specified = !mp_meta->primary_handle_prefix.empty();
                    if FK_YAML_UNLIKELY (is_already_specified) {
                        throw parse_error(
                            "Primary handle cannot be specified more than once.",
                            lexer.get_lines_processed(),
                            lexer.get_last_token_begin_pos());
                    }
                    const str_view tag_prefix = lexer.get_tag_prefix();
                    mp_meta->primary_handle_prefix.assign(tag_prefix.begin(), tag_prefix.end());
                    lacks_end_of_directives_marker = true;
                    break;
                }
                case 2 /* !! */: {
                    const bool is_already_specified = !mp_meta->secondary_handle_prefix.empty();
                    if FK_YAML_UNLIKELY (is_already_specified) {
                        throw parse_error(
                            "Secondary handle cannot be specified more than once.",
                            lexer.get_lines_processed(),
                            lexer.get_last_token_begin_pos());
                    }
                    const str_view tag_prefix = lexer.get_tag_prefix();
                    mp_meta->secondary_handle_prefix.assign(tag_prefix.begin(), tag_prefix.end());
                    lacks_end_of_directives_marker = true;
                    break;
                }
                default /* !<handle>! */: {
                    std::string tag_handle(tag_handle_view.begin(), tag_handle_view.end());
                    const str_view tag_prefix_view = lexer.get_tag_prefix();
                    std::string tag_prefix(tag_prefix_view.begin(), tag_prefix_view.end());
                    const bool is_already_specified =
                        !(mp_meta->named_handle_map.emplace(std::move(tag_handle), std::move(tag_prefix)).second);
                    if FK_YAML_UNLIKELY (is_already_specified) {
                        throw parse_error(
                            "The same named handle cannot be specified more than once.",
                            lexer.get_lines_processed(),
                            lexer.get_last_token_begin_pos());
                    }
                    lacks_end_of_directives_marker = true;
                    break;
                }
                }
                break;
            }
            case lexical_token_t::INVALID_DIRECTIVE:
                // TODO: should output a warning log. Currently just ignore this case.
                break;
            case lexical_token_t::END_OF_DIRECTIVES:
                lacks_end_of_directives_marker = false;
                break;
            default:
                if FK_YAML_UNLIKELY (lacks_end_of_directives_marker) {
                    throw parse_error(
                        "The end of directives marker (---) is missing after directives.",
                        lexer.get_lines_processed(),
                        lexer.get_last_token_begin_pos());
                }
                // end the parsing of directives if the other tokens are found.
                last_token = token;
                lexer.set_document_state(false);
                return;
            }
        }
    }

    /// @brief Deserializes the YAML nodes recursively.
    /// @param lexer The lexical analyzer to be used.
    /// @param first_type The first lexical token.
    /// @param last_type Storage for last lexical token type.
    void deserialize_node(
        lexer_type& lexer, const lexical_token& first_token, uint32_t first_line, uint32_t first_indent,
        lexical_token_t& last_type) {
        lexical_token token = first_token;
        uint32_t line = first_line;
        uint32_t indent = first_indent;

        do {
            switch (token.type) {
            case lexical_token_t::EXPLICIT_KEY_PREFIX: {
                const bool needs_to_move_back = indent == 0 || indent < m_context_stack.back().indent;
                if (needs_to_move_back) {
                    pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                        return c.state == context_state_t::BLOCK_MAPPING && indent == c.indent;
                    });
                }

                switch (m_context_stack.back().state) {
                case context_state_t::MAPPING_VALUE:
                case context_state_t::BLOCK_MAPPING_EXPLICIT_KEY:
                case context_state_t::BLOCK_MAPPING_EXPLICIT_VALUE:
                case context_state_t::BLOCK_SEQUENCE_ENTRY:
                    // This path is needed in case the input contains nested explicit keys.
                    // ```yaml
                    // foo:
                    //   ? ? foo
                    //     : bar
                    //   : ? baz
                    //     : - ? qux
                    //         : 123
                    // ```
                    *mp_current_node = basic_node_type::mapping();
                    apply_directive_set(*mp_current_node);
                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                    break;
                default:
                    break;
                }

                token = lexer.get_next_token();
                if (token.type == lexical_token_t::SEQUENCE_BLOCK_PREFIX) {
                    // heap-allocated node will be freed in handling the corresponding KEY_SEPARATOR event
                    auto* p_node = new basic_node_type(node_type::SEQUENCE);
                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING_EXPLICIT_KEY, p_node);

                    apply_directive_set(*p_node);
                    parse_context context(
                        lexer.get_lines_processed(),
                        lexer.get_last_token_begin_pos(),
                        context_state_t::BLOCK_SEQUENCE,
                        p_node);
                    m_context_stack.emplace_back(context);

                    p_node->as_seq().emplace_back(basic_node_type());
                    mp_current_node = &(p_node->as_seq().back());
                    apply_directive_set(*mp_current_node);
                    context.state = context_state_t::BLOCK_SEQUENCE_ENTRY;
                    context.p_node = mp_current_node;
                    m_context_stack.emplace_back(std::move(context));

                    break;
                }

                // heap-allocated node will be freed in handling the corresponding KEY_SEPARATOR event
                m_context_stack.emplace_back(
                    line, indent, context_state_t::BLOCK_MAPPING_EXPLICIT_KEY, new basic_node_type());
                mp_current_node = m_context_stack.back().p_node;
                apply_directive_set(*mp_current_node);
                indent = lexer.get_last_token_begin_pos();
                line = lexer.get_lines_processed();

                continue;
            }
            case lexical_token_t::KEY_SEPARATOR: {
                FK_YAML_ASSERT(!m_context_stack.empty());
                if FK_YAML_UNLIKELY (m_context_stack.back().state == context_state_t::BLOCK_SEQUENCE_ENTRY) {
                    // empty mapping keys are not supported.
                    // ```yaml
                    // - : foo
                    // ```
                    throw parse_error("sequence key should not be empty.", line, indent);
                }

                if (m_flow_context_depth > 0) {
                    break;
                }

                // hold the line count of the key separator for later use.
                const uint32_t old_indent = indent;
                const uint32_t old_line = line;

                token = lexer.get_next_token();
                line = lexer.get_lines_processed();
                indent = lexer.get_last_token_begin_pos();

                const bool found_props = deserialize_node_properties(lexer, token, line, indent);
                if (found_props && line == lexer.get_lines_processed()) {
                    // defer applying node properties for the subsequent node on the same line.
                    continue;
                }

                line = lexer.get_lines_processed();
                indent = lexer.get_last_token_begin_pos();

                const bool is_implicit_same_line =
                    (line == old_line) && (m_context_stack.empty() || old_indent > m_context_stack.back().indent);
                if (is_implicit_same_line) {
                    // a key separator for an implicit key with its value on the same line.
                    continue;
                }

                if (line > old_line) {
                    if (m_needs_tag_impl) {
                        const tag_t tag_type = tag_resolver_type::resolve_tag(m_tag_name, mp_meta);
                        if (tag_type == tag_t::MAPPING || tag_type == tag_t::CUSTOM_TAG) {
                            // set YAML node properties here to distinguish them from those for the first key node
                            // as shown in the following snippet:
                            //
                            // ```yaml
                            // foo: !!map
                            //   !!str 123: true
                            //   ^
                            //   this !!str tag overwrites the preceding !!map tag.
                            // ```
                            *mp_current_node = basic_node_type::mapping();
                            apply_directive_set(*mp_current_node);
                            apply_node_properties(*mp_current_node);
                            m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                            continue;
                        }
                    }

                    if (token.type == lexical_token_t::SEQUENCE_BLOCK_PREFIX) {
                        // a key separator preceding block sequence entries
                        *mp_current_node = basic_node_type::sequence({basic_node_type()});
                        apply_directive_set(*mp_current_node);
                        apply_node_properties(*mp_current_node);
                        auto& cur_context = m_context_stack.back();
                        cur_context.line = line;
                        cur_context.indent = indent;
                        cur_context.state = context_state_t::BLOCK_SEQUENCE;

                        mp_current_node = &(mp_current_node->as_seq().back());
                        apply_directive_set(*mp_current_node);
                        parse_context entry_context = cur_context;
                        entry_context.state = context_state_t::BLOCK_SEQUENCE_ENTRY;
                        entry_context.p_node = mp_current_node;
                        m_context_stack.emplace_back(std::move(entry_context));

                        token = lexer.get_next_token();
                        line = lexer.get_lines_processed();
                        indent = lexer.get_last_token_begin_pos();

                        const bool has_props = deserialize_node_properties(lexer, token, line, indent);
                        if (has_props) {
                            const uint32_t line_after_props = lexer.get_lines_processed();
                            if (line == line_after_props) {
                                // Skip updating the current indent to avoid stacking a wrong indentation.
                                //
                                // ```yaml
                                // &foo bar: baz
                                // ^
                                // the correct indent width for the "bar" node key.
                                // ```
                                continue;
                            }

                            // if node properties and the followed node are on different lines (i.e., the properties are
                            // for a container node), the application and the line advancement must happen here.
                            // Otherwise, a false indent error will be emitted. See
                            // https://github.com/fktn-k/fkYAML/issues/368 for more details.
                            line = line_after_props;
                            indent = lexer.get_last_token_begin_pos();
                            *mp_current_node = basic_node_type::mapping();
                            m_context_stack.emplace_back(
                                line_after_props, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                            apply_directive_set(*mp_current_node);
                            apply_node_properties(*mp_current_node);
                        }

                        continue;
                    }

                    if (indent <= m_context_stack.back().indent) {
                        FK_YAML_ASSERT(m_context_stack.back().state == context_state_t::MAPPING_VALUE);

                        // Mapping values can be omitted and are considered to be null.
                        // ```yaml
                        // foo:
                        // bar:
                        //   baz:
                        // qux:
                        // # -> {foo: null, bar: {baz: null}, qux: null}
                        // ```
                        pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                            return (c.state == context_state_t::BLOCK_MAPPING) && (indent == c.indent);
                        });
                    }

                    // defer checking the existence of a key separator after the following scalar until the next
                    // deserialize_scalar() call.
                    continue;
                }

                // handle explicit mapping key separators.
                FK_YAML_ASSERT(m_context_stack.back().state == context_state_t::BLOCK_MAPPING_EXPLICIT_KEY);

                basic_node_type key_node = std::move(*m_context_stack.back().p_node);
                m_context_stack.pop_back();
                m_context_stack.back().p_node->as_map().emplace(key_node, basic_node_type());
                mp_current_node = &(m_context_stack.back().p_node->operator[](std::move(key_node)));
                m_context_stack.emplace_back(
                    old_line, old_indent, context_state_t::BLOCK_MAPPING_EXPLICIT_VALUE, mp_current_node);

                if (token.type == lexical_token_t::SEQUENCE_BLOCK_PREFIX) {
                    *mp_current_node = basic_node_type::sequence({basic_node_type()});
                    apply_directive_set(*mp_current_node);
                    apply_node_properties(*mp_current_node);
                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_SEQUENCE, mp_current_node);

                    mp_current_node = &(mp_current_node->as_seq().back());
                    parse_context entry_context = m_context_stack.back();
                    entry_context.state = context_state_t::BLOCK_SEQUENCE_ENTRY;
                    entry_context.p_node = mp_current_node;
                    m_context_stack.emplace_back(std::move(entry_context));
                    break;
                }

                continue;
            }
            case lexical_token_t::ANCHOR_PREFIX:
            case lexical_token_t::TAG_PREFIX:
                deserialize_node_properties(lexer, token, line, indent);
                // Skip updating the current indent to avoid stacking a wrong indentation.
                // Note that node properties for block sequences as a mapping value are processed when a
                // `lexical_token_t::KEY_SEPARATOR` token is processed.
                //
                // ```yaml
                // &foo bar: baz
                // ^
                // the correct indent width for the "bar" node key.
                // ```
                continue;
            case lexical_token_t::SEQUENCE_BLOCK_PREFIX: {
                FK_YAML_ASSERT(!m_context_stack.empty());
                const uint32_t parent_indent = m_context_stack.back().indent;
                if (indent == parent_indent) {
                    // If the previous block sequence entry is empty, just move to the parent context.
                    // ```yaml
                    // foo:
                    //   -
                    //   - bar
                    // # ^ (here)
                    // # -> {foo: [null, bar]}
                    // ```
                    pop_to_parent_node(line, indent, [](const parse_context& c) {
                        return c.state == context_state_t::BLOCK_SEQUENCE;
                    });
                }
                else if (indent < parent_indent) {
                    pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                        return c.state == context_state_t::BLOCK_SEQUENCE && indent == c.indent;
                    });
                }
                else /*parent_indent < indent*/ {
                    if FK_YAML_UNLIKELY (m_context_stack.back().state == context_state_t::BLOCK_SEQUENCE) {
                        // bad indentation like the following YAML:
                        // ```yaml
                        // - "foo"
                        //   - bar
                        // # ^
                        // ```
                        throw parse_error("bad indentation of a mapping entry.", line, indent);
                    }

                    *mp_current_node = basic_node_type::sequence();
                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_SEQUENCE, mp_current_node);
                    apply_directive_set(*mp_current_node);
                    apply_node_properties(*mp_current_node);
                }

                auto& seq = mp_current_node->as_seq();
                seq.emplace_back(basic_node_type());
                mp_current_node = &(seq.back());
                apply_directive_set(*mp_current_node);
                m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_SEQUENCE_ENTRY, mp_current_node);
                break;
            }
            case lexical_token_t::SEQUENCE_FLOW_BEGIN:
                if (m_flow_context_depth == 0) {
                    lexer.set_context_state(true);

                    if (indent <= m_context_stack.back().indent) {
                        pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                            switch (c.state) {
                            case context_state_t::BLOCK_MAPPING:
                            case context_state_t::MAPPING_VALUE:
                                return indent == c.indent;
                            default:
                                return false;
                            }
                        });
                    }
                }
                else if FK_YAML_UNLIKELY (m_flow_token_state == flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX) {
                    throw parse_error("Flow sequence beginning is found without separated with a comma.", line, indent);
                }

                ++m_flow_context_depth;

                switch (m_context_stack.back().state) {
                case context_state_t::BLOCK_SEQUENCE:
                case context_state_t::FLOW_SEQUENCE:
                    mp_current_node->as_seq().emplace_back(basic_node_type::sequence());
                    mp_current_node = &(mp_current_node->as_seq().back());
                    m_context_stack.emplace_back(line, indent, context_state_t::FLOW_SEQUENCE, mp_current_node);
                    break;
                case context_state_t::BLOCK_MAPPING:
                case context_state_t::FLOW_MAPPING:
                    // heap-allocated node will be freed in handling the corresponding SEQUENCE_FLOW_END event.
                    m_context_stack.emplace_back(
                        line, indent, context_state_t::FLOW_SEQUENCE_KEY, new basic_node_type(node_type::SEQUENCE));
                    mp_current_node = m_context_stack.back().p_node;
                    break;
                default: {
                    *mp_current_node = basic_node_type::sequence();
                    parse_context& last_context = m_context_stack.back();
                    last_context.line = line;
                    last_context.indent = indent;
                    last_context.state = context_state_t::FLOW_SEQUENCE;
                    break;
                }
                }

                apply_directive_set(*mp_current_node);
                apply_node_properties(*mp_current_node);

                m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;
                break;
            case lexical_token_t::SEQUENCE_FLOW_END: {
                if FK_YAML_UNLIKELY (m_flow_context_depth == 0) {
                    throw parse_error("Flow sequence ending is found outside the flow context.", line, indent);
                }

                if (--m_flow_context_depth == 0) {
                    lexer.set_context_state(false);
                }

                // find the corresponding flow sequence beginning.
                auto itr = std::find_if( // LCOV_EXCL_LINE
                    m_context_stack.rbegin(),
                    m_context_stack.rend(),
                    [](const parse_context& c) {
                        switch (c.state) {
                        case context_state_t::FLOW_SEQUENCE_KEY:
                        case context_state_t::FLOW_SEQUENCE:
                            return true;
                        default:
                            return false;
                        }
                    });

                const bool is_valid = itr != m_context_stack.rend();
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw parse_error("No corresponding flow sequence beginning is found.", line, indent);
                }

                // keep the last state for later processing.
                parse_context& last_context = m_context_stack.back();
                mp_current_node = last_context.p_node;
                last_context.p_node = nullptr;
                indent = last_context.indent;
                const context_state_t state = last_context.state;
                m_context_stack.pop_back();

                // handle cases where the flow sequence is a mapping key node.

                if (!m_context_stack.empty() && state == context_state_t::FLOW_SEQUENCE_KEY) {
                    basic_node_type key_node = std::move(*mp_current_node);
                    delete mp_current_node;
                    mp_current_node = m_context_stack.back().p_node;
                    m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;

                    add_new_key(std::move(key_node), line, indent);
                    break;
                }

                token = lexer.get_next_token();
                if (token.type == lexical_token_t::KEY_SEPARATOR) {
                    basic_node_type key_node = basic_node_type::mapping();
                    apply_directive_set(key_node);
                    mp_current_node->swap(key_node);

                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                    m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;

                    add_new_key(std::move(key_node), line, indent);
                }
                else {
                    if (!m_context_stack.empty()) {
                        mp_current_node = m_context_stack.back().p_node;
                    }
                    if (m_flow_context_depth > 0) {
                        m_flow_token_state = flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX;
                    }
                }

                indent = lexer.get_last_token_begin_pos();
                line = lexer.get_lines_processed();
                continue;
            }
            case lexical_token_t::MAPPING_FLOW_BEGIN:
                if (m_flow_context_depth == 0) {
                    lexer.set_context_state(true);

                    if (indent <= m_context_stack.back().indent) {
                        pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                            switch (c.state) {
                            case context_state_t::BLOCK_MAPPING:
                            case context_state_t::MAPPING_VALUE:
                                return indent == c.indent;
                            default:
                                return false;
                            }
                        });
                    }
                }
                else if FK_YAML_UNLIKELY (m_flow_token_state == flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX) {
                    throw parse_error("Flow mapping beginning is found without separated with a comma.", line, indent);
                }

                ++m_flow_context_depth;

                switch (m_context_stack.back().state) {
                case context_state_t::BLOCK_SEQUENCE:
                case context_state_t::FLOW_SEQUENCE:
                    mp_current_node->as_seq().emplace_back(basic_node_type::mapping());
                    mp_current_node = &(mp_current_node->as_seq().back());
                    m_context_stack.emplace_back(line, indent, context_state_t::FLOW_MAPPING, mp_current_node);
                    break;
                case context_state_t::BLOCK_MAPPING:
                case context_state_t::FLOW_MAPPING:
                    // heap-allocated node will be freed in handling the corresponding MAPPING_FLOW_END event.
                    m_context_stack.emplace_back(
                        line, indent, context_state_t::FLOW_MAPPING_KEY, new basic_node_type(node_type::MAPPING));
                    mp_current_node = m_context_stack.back().p_node;
                    break;
                default: {
                    *mp_current_node = basic_node_type::mapping();
                    parse_context& last_context = m_context_stack.back();
                    last_context.line = line;
                    last_context.indent = indent;
                    last_context.state = context_state_t::FLOW_MAPPING;
                    break;
                }
                }

                apply_directive_set(*mp_current_node);
                apply_node_properties(*mp_current_node);

                line = lexer.get_lines_processed();
                indent = lexer.get_last_token_begin_pos();

                m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;
                break;
            case lexical_token_t::MAPPING_FLOW_END: {
                if FK_YAML_UNLIKELY (m_flow_context_depth == 0) {
                    throw parse_error("Flow mapping ending is found outside the flow context.", line, indent);
                }

                if (--m_flow_context_depth == 0) {
                    lexer.set_context_state(false);
                }

                // find the corresponding flow mapping beginning.
                auto itr = std::find_if( // LCOV_EXCL_LINE
                    m_context_stack.rbegin(),
                    m_context_stack.rend(),
                    [](const parse_context& c) {
                        switch (c.state) {
                        case context_state_t::FLOW_MAPPING_KEY:
                        case context_state_t::FLOW_MAPPING:
                            return true;
                        default:
                            return false;
                        }
                    });

                const bool is_valid = itr != m_context_stack.rend();
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw parse_error("No corresponding flow mapping beginning is found.", line, indent);
                }

                // keep the last state for later processing.
                parse_context& last_context = m_context_stack.back();
                mp_current_node = last_context.p_node;
                last_context.p_node = nullptr;
                indent = last_context.indent;
                const context_state_t state = last_context.state;
                m_context_stack.pop_back();

                // handle cases where the flow mapping is a mapping key node.

                if (!m_context_stack.empty() && state == context_state_t::FLOW_MAPPING_KEY) {
                    basic_node_type key_node = std::move(*mp_current_node);
                    delete mp_current_node;
                    mp_current_node = m_context_stack.back().p_node;
                    m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;

                    add_new_key(std::move(key_node), line, indent);
                    break;
                }

                token = lexer.get_next_token();
                if (token.type == lexical_token_t::KEY_SEPARATOR) {
                    basic_node_type key_node = basic_node_type::mapping();
                    apply_directive_set(key_node);
                    mp_current_node->swap(key_node);

                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                    m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;

                    add_new_key(std::move(key_node), line, indent);
                }
                else {
                    if (!m_context_stack.empty()) {
                        mp_current_node = m_context_stack.back().p_node;
                    }
                    if (m_flow_context_depth > 0) {
                        m_flow_token_state = flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX;
                    }
                }

                indent = lexer.get_last_token_begin_pos();
                line = lexer.get_lines_processed();
                continue;
            }
            case lexical_token_t::VALUE_SEPARATOR:
                FK_YAML_ASSERT(m_flow_context_depth > 0);
                if FK_YAML_UNLIKELY (m_flow_token_state != flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX) {
                    throw parse_error("invalid value separator is found.", line, indent);
                }
                m_flow_token_state = flow_token_state_t::NEEDS_VALUE_OR_SUFFIX;
                break;
            case lexical_token_t::ALIAS_PREFIX: {
                // An alias node must not specify any properties (tag, anchor).
                // https://yaml.org/spec/1.2.2/#71-alias-nodes
                if FK_YAML_UNLIKELY (m_needs_tag_impl) {
                    throw parse_error("Tag cannot be specified to an alias node", line, indent);
                }
                if FK_YAML_UNLIKELY (m_needs_anchor_impl) {
                    throw parse_error("Anchor cannot be specified to an alias node.", line, indent);
                }

                std::string token_str = std::string(token.str.begin(), token.str.end());

                const auto anchor_counts = static_cast<uint32_t>(mp_meta->anchor_table.count(token_str));
                if FK_YAML_UNLIKELY (anchor_counts == 0) {
                    throw parse_error("The given anchor name must appear prior to the alias node.", line, indent);
                }

                basic_node_type node {};
                node.m_attrs |= detail::node_attr_bits::alias_bit;
                node.m_prop.anchor = std::move(token_str);
                detail::node_attr_bits::set_anchor_offset(anchor_counts - 1, node.m_attrs);

                apply_directive_set(node);
                apply_node_properties(node);

                deserialize_scalar(lexer, std::move(node), indent, line, token);
                continue;
            }
            case lexical_token_t::PLAIN_SCALAR:
            case lexical_token_t::SINGLE_QUOTED_SCALAR:
            case lexical_token_t::DOUBLE_QUOTED_SCALAR: {
                tag_t tag_type {tag_t::NONE};
                if (m_needs_tag_impl) {
                    tag_type = tag_resolver_type::resolve_tag(m_tag_name, mp_meta);
                }

                basic_node_type node = scalar_parser_type(line, indent).parse_flow(token.type, tag_type, token.str);
                apply_directive_set(node);
                apply_node_properties(node);

                deserialize_scalar(lexer, std::move(node), indent, line, token);
                continue;
            }
            case lexical_token_t::BLOCK_LITERAL_SCALAR:
            case lexical_token_t::BLOCK_FOLDED_SCALAR: {
                tag_t tag_type {tag_t::NONE};
                if (m_needs_tag_impl) {
                    tag_type = tag_resolver_type::resolve_tag(m_tag_name, mp_meta);
                }

                basic_node_type node =
                    scalar_parser_type(line, indent)
                        .parse_block(token.type, tag_type, token.str, lexer.get_block_scalar_header());
                apply_directive_set(node);
                apply_node_properties(node);

                deserialize_scalar(lexer, std::move(node), indent, line, token);
                continue;
            }
            // these tokens end parsing the current YAML document.
            case lexical_token_t::END_OF_BUFFER:
                // This handles an empty input.
                last_type = token.type;
                return;
            case lexical_token_t::END_OF_DIRECTIVES:
            case lexical_token_t::END_OF_DOCUMENT:
                if FK_YAML_UNLIKELY (m_flow_context_depth > 0) {
                    throw parse_error("An invalid document marker found in a flow collection", line, indent);
                }
                last_type = token.type;
                return;
            // no way to come here while lexically analyzing document contents.
            case lexical_token_t::YAML_VER_DIRECTIVE: // LCOV_EXCL_LINE
            case lexical_token_t::TAG_DIRECTIVE:      // LCOV_EXCL_LINE
            case lexical_token_t::INVALID_DIRECTIVE:  // LCOV_EXCL_LINE
                detail::unreachable();                // LCOV_EXCL_LINE
            }

            token = lexer.get_next_token();
            indent = lexer.get_last_token_begin_pos();
            line = lexer.get_lines_processed();
        } while (token.type != lexical_token_t::END_OF_BUFFER);

        last_type = token.type;
    }

    /// @brief Deserializes YAML node properties (anchor and/or tag names) if they exist
    /// @param lexer The lexical analyzer to be used.
    /// @param last_type The variable to store the last lexical token type.
    /// @param line The variable to store the line of either the first property or the last non-property token.
    /// @param indent The variable to store the indent of either the first property or the last non-property token.
    /// @return true if any property is found, false otherwise.
    bool deserialize_node_properties(lexer_type& lexer, lexical_token& last_token, uint32_t& line, uint32_t& indent) {
        m_needs_anchor_impl = m_needs_tag_impl = false;

        lexical_token token = last_token;
        bool ends_loop {false};
        do {
            if (line < lexer.get_lines_processed()) {
                break;
            }

            switch (token.type) {
            case lexical_token_t::ANCHOR_PREFIX:
                if FK_YAML_UNLIKELY (m_needs_anchor_impl) {
                    throw parse_error(
                        "anchor name cannot be specified more than once to the same node.",
                        lexer.get_lines_processed(),
                        lexer.get_last_token_begin_pos());
                }

                m_anchor_name = token.str;
                m_needs_anchor_impl = true;

                if (!m_needs_tag_impl) {
                    line = lexer.get_lines_processed();
                    indent = lexer.get_last_token_begin_pos();
                }

                token = lexer.get_next_token();
                break;
            case lexical_token_t::TAG_PREFIX: {
                if FK_YAML_UNLIKELY (m_needs_tag_impl) {
                    throw parse_error(
                        "tag name cannot be specified more than once to the same node.",
                        lexer.get_lines_processed(),
                        lexer.get_last_token_begin_pos());
                }

                m_tag_name = token.str;
                m_needs_tag_impl = true;

                if (!m_needs_anchor_impl) {
                    line = lexer.get_lines_processed();
                    indent = lexer.get_last_token_begin_pos();
                }

                token = lexer.get_next_token();
                break;
            }
            default:
                ends_loop = true;
                break;
            }
        } while (!ends_loop);

        last_token = token;
        const bool prop_specified = m_needs_anchor_impl || m_needs_tag_impl;
        if (!prop_specified) {
            line = lexer.get_lines_processed();
            indent = lexer.get_last_token_begin_pos();
        }

        return prop_specified;
    }

    /// @brief Add new key string to the current YAML node.
    /// @param key a key string to be added to the current YAML node.
    /// @param line The line where the key is found.
    /// @param indent The indentation width in the current line where the key is found.
    void add_new_key(basic_node_type&& key, const uint32_t line, const uint32_t indent) {
        if (m_flow_context_depth == 0) {
            if FK_YAML_UNLIKELY (m_context_stack.back().indent < indent) {
                // bad indentation like the following YAML:
                // ```yaml
                // foo: true
                //   baz: 123
                // # ^
                // ```
                throw parse_error("bad indentation of a mapping entry.", line, indent);
            }

            pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                return (c.state == context_state_t::BLOCK_MAPPING) && (indent == c.indent);
            });
        }
        else {
            if FK_YAML_UNLIKELY (m_flow_token_state != flow_token_state_t::NEEDS_VALUE_OR_SUFFIX) {
                throw parse_error("Flow mapping entry is found without separated with a comma.", line, indent);
            }

            if (mp_current_node->is_sequence()) {
                mp_current_node->as_seq().emplace_back(basic_node_type::mapping());
                mp_current_node = &(mp_current_node->operator[](mp_current_node->size() - 1));
                m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
            }
        }

        auto itr = mp_current_node->as_map().emplace(std::move(key), basic_node_type());
        if FK_YAML_UNLIKELY (!itr.second) {
            throw parse_error("Detected duplication in mapping keys.", line, indent);
        }

        mp_current_node = &(itr.first->second);
        const parse_context& key_context = m_context_stack.back();
        m_context_stack.emplace_back(
            key_context.line, key_context.indent, context_state_t::MAPPING_VALUE, mp_current_node);
    }

    /// @brief Assign node value to the current node.
    /// @param node_value A rvalue basic_node_type object to be assigned to the current node.
    void assign_node_value(basic_node_type&& node_value, const uint32_t line, const uint32_t indent) {
        if (mp_current_node->is_sequence()) {
            FK_YAML_ASSERT(m_flow_context_depth > 0);

            if FK_YAML_UNLIKELY (m_flow_token_state != flow_token_state_t::NEEDS_VALUE_OR_SUFFIX) {
                // Flow sequence entries are not allowed to be empty.
                // ```yaml
                // [foo,,bar]
                // ```
                throw parse_error("flow sequence entry is found without separated with a comma.", line, indent);
            }

            mp_current_node->as_seq().emplace_back(std::move(node_value));
            m_flow_token_state = flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX;
            return;
        }

        // a scalar node
        *mp_current_node = std::move(node_value);
        if FK_YAML_UNLIKELY (m_context_stack.empty()) {
            // single scalar document.
            return;
        }

        if FK_YAML_LIKELY (m_context_stack.back().state != context_state_t::BLOCK_MAPPING_EXPLICIT_KEY) {
            m_context_stack.pop_back();
            mp_current_node = m_context_stack.back().p_node;

            if (m_flow_context_depth > 0) {
                m_flow_token_state = flow_token_state_t::NEEDS_SEPARATOR_OR_SUFFIX;
            }
        }
    }

    /// @brief Deserialize a detected scalar node.
    /// @param lexer The lexical analyzer to be used.
    /// @param node A scalar node.
    /// @param indent The current indentation width. Can be updated in this function.
    /// @param line The number of processed lines. Can be updated in this function.
    /// @param token The storage for last lexical token.
    /// @return true if next token has already been got, false otherwise.
    void deserialize_scalar(
        lexer_type& lexer, basic_node_type&& node, uint32_t& indent, uint32_t& line, lexical_token& token) {
        token = lexer.get_next_token();
        if (mp_current_node->is_mapping()) {
            const bool is_key_sep_followed =
                (token.type == lexical_token_t::KEY_SEPARATOR) && (line == lexer.get_lines_processed());
            if FK_YAML_UNLIKELY (!is_key_sep_followed) {
                throw parse_error(
                    "The \":\" mapping value indicator must be followed after a mapping key.",
                    lexer.get_lines_processed(),
                    lexer.get_last_token_begin_pos());
            }
            add_new_key(std::move(node), line, indent);
        }
        else if (token.type == lexical_token_t::KEY_SEPARATOR) {
            if FK_YAML_UNLIKELY (line != lexer.get_lines_processed()) {
                // This path is for explicit mapping key separator like:
                // ```yaml
                //   ? foo
                //   : bar
                // # ^ this separator
                // ```
                assign_node_value(std::move(node), line, indent);
                indent = lexer.get_last_token_begin_pos();
                line = lexer.get_lines_processed();

                if (m_context_stack.back().state != context_state_t::BLOCK_MAPPING_EXPLICIT_KEY) {
                    pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                        return c.state == context_state_t::BLOCK_MAPPING_EXPLICIT_KEY && indent == c.indent;
                    });
                }
                return;
            }

            if (mp_current_node->is_scalar()) {
                if FK_YAML_LIKELY (!m_context_stack.empty()) {
                    parse_context& cur_context = m_context_stack.back();
                    switch (cur_context.state) {
                    case context_state_t::BLOCK_MAPPING_EXPLICIT_KEY:
                    case context_state_t::BLOCK_MAPPING_EXPLICIT_VALUE:
                        m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                        break;
                    case context_state_t::BLOCK_SEQUENCE_ENTRY:
                        if FK_YAML_UNLIKELY (cur_context.indent >= indent) {
                            // This handles combination of empty block sequence entry and block mapping entry with the
                            // same indentation level, for examples:
                            // ```yaml
                            // foo:
                            //   bar:
                            //   -         # These entries are indented
                            //   baz: 123  # with the same width.
                            // # ^^^
                            // ```
                            pop_to_parent_node(line, indent, [indent](const parse_context& c) {
                                return c.state == context_state_t::BLOCK_MAPPING && indent == c.indent;
                            });
                            add_new_key(std::move(node), line, indent);
                            indent = lexer.get_last_token_begin_pos();
                            line = lexer.get_lines_processed();
                            return;
                        }

                        m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                        break;
                    default:
                        if FK_YAML_UNLIKELY (cur_context.line == line) {
                            throw parse_error("Multiple mapping keys are specified on the same line.", line, indent);
                        }
                        cur_context.line = line;
                        cur_context.indent = indent;
                        cur_context.state = context_state_t::BLOCK_MAPPING;
                        break;
                    }

                    *mp_current_node = basic_node_type::mapping();
                    apply_directive_set(*mp_current_node);
                }
                else {
                    // root mapping node

                    m_context_stack.emplace_back(line, indent, context_state_t::BLOCK_MAPPING, mp_current_node);
                    *mp_current_node = basic_node_type::mapping();
                    apply_directive_set(*mp_current_node);

                    // apply node properties if any to the root mapping node.
                    if (!m_root_anchor_name.empty()) {
                        mp_current_node->add_anchor_name(
                            std::string(m_root_anchor_name.begin(), m_root_anchor_name.end()));
                        m_root_anchor_name = {};
                    }
                    if (!m_root_tag_name.empty()) {
                        mp_current_node->add_tag_name(std::string(m_root_tag_name.begin(), m_root_tag_name.end()));
                        m_root_tag_name = {};
                    }
                }
            }
            add_new_key(std::move(node), line, indent);
        }
        else {
            assign_node_value(std::move(node), line, indent);
        }

        indent = lexer.get_last_token_begin_pos();
        line = lexer.get_lines_processed();
    }

    /// @brief Pops parent contexts to a block mapping with the given indentation.
    /// @tparam Pred Functor type to test parent contexts.
    /// @param line The current line count.
    /// @param indent The indentation level of the target parent block mapping.
    template <typename Pred>
    void pop_to_parent_node(uint32_t line, uint32_t indent, Pred&& pred) {
        FK_YAML_ASSERT(!m_context_stack.empty());

        // LCOV_EXCL_START
        auto itr = std::find_if(m_context_stack.rbegin(), m_context_stack.rend(), std::forward<Pred>(pred));
        // LCOV_EXCL_STOP
        const bool is_indent_valid = (itr != m_context_stack.rend());
        if FK_YAML_UNLIKELY (!is_indent_valid) {
            throw parse_error("Detected invalid indentation.", line, indent);
        }

        const auto pop_num = static_cast<uint32_t>(std::distance(m_context_stack.rbegin(), itr));

        // move back to the parent block mapping.
        for (uint32_t i = 0; i < pop_num; i++) {
            m_context_stack.pop_back();
        }
        mp_current_node = m_context_stack.back().p_node;
    }

    /// @brief Set YAML directive properties to the given node.
    /// @param node A basic_node_type object to be set YAML directive properties.
    void apply_directive_set(basic_node_type& node) noexcept {
        node.mp_meta = mp_meta;
    }

    /// @brief Set YAML node properties (anchor and/or tag names) to the given node.
    /// @param node A node type object to be set YAML node properties.
    void apply_node_properties(basic_node_type& node) {
        if (m_needs_anchor_impl) {
            node.add_anchor_name(std::string(m_anchor_name.begin(), m_anchor_name.end()));
            m_needs_anchor_impl = false;
            m_anchor_name = {};
        }

        if (m_needs_tag_impl) {
            node.add_tag_name(std::string(m_tag_name.begin(), m_tag_name.end()));
            m_needs_tag_impl = false;
            m_tag_name = {};
        }
    }

    /// @brief Update the target YAML version with an input string.
    /// @param version_str A YAML version string.
    yaml_version_type convert_yaml_version(str_view version_str) noexcept {
        return (version_str.compare("1.1") == 0) ? yaml_version_type::VERSION_1_1 : yaml_version_type::VERSION_1_2;
    }

private:
    /// The currently focused YAML node.
    basic_node_type* mp_current_node {nullptr};
    /// The stack of parse contexts.
    std::deque<parse_context> m_context_stack {};
    /// The current depth of flow contexts.
    uint32_t m_flow_context_depth {0};
    /// The set of YAML directives.
    std::shared_ptr<doc_metainfo_type> mp_meta {};
    /// A flag to determine the need for YAML anchor node implementation.
    bool m_needs_anchor_impl {false};
    /// A flag to determine the need for a corresponding node with the last YAML tag.
    bool m_needs_tag_impl {false};
    /// A flag to determine the need for a value separator or a flow suffix to follow.
    flow_token_state_t m_flow_token_state {flow_token_state_t::NEEDS_VALUE_OR_SUFFIX};
    /// The last YAML anchor name.
    str_view m_anchor_name;
    /// The last tag name.
    str_view m_tag_name;
    /// The root YAML anchor name. (maybe empty and unused)
    str_view m_root_anchor_name;
    /// The root tag name. (maybe empty and unused)
    str_view m_root_tag_name;
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_DESERIALIZER_HPP */

// #include <fkYAML/detail/input/input_adapter.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_INPUT_INPUT_ADAPTER_HPP
#define FK_YAML_DETAIL_INPUT_INPUT_ADAPTER_HPP

#include <array>
#include <cstdio>
#include <cstring>
#include <deque>
#include <istream>
#include <iterator>
#include <string>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/assert.hpp>

// #include <fkYAML/detail/encodings/utf_encode_detector.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_DETECTOR_HPP
#define FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_DETECTOR_HPP

#include <cstdint>
#include <istream>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/encodings/utf_encode_t.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_T_HPP
#define FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_T_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of Unicode encoding types
/// @note Since fkYAML doesn't treat UTF-16/UTF-32 encoded characters per byte, endians do not matter.
enum class utf_encode_t : std::uint8_t {
    UTF_8,    //!< UTF-8
    UTF_16BE, //!< UTF-16 Big Endian
    UTF_16LE, //!< UTF-16 Little Endian
    UTF_32BE, //!< UTF-32 Big Endian
    UTF_32LE, //!< UTF-32 Little Endian
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_T_HPP */

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Detect an encoding type for UTF-8 expected inputs.
/// @note This function doesn't support the case where the first character is null.
/// @param[in] bytes 4 bytes of an input character sequence.
/// @param[out] has_bom Whether the input contains a BOM.
/// @return A detected encoding type.
inline utf_encode_t detect_encoding_type(const std::array<uint8_t, 4>& bytes, bool& has_bom) noexcept {
    has_bom = false;

    const uint8_t byte0 = bytes[0];
    const uint8_t byte1 = bytes[1];
    const uint8_t byte2 = bytes[2];
    const uint8_t byte3 = bytes[3];

    // Check if a BOM exists.

    if (byte0 == static_cast<uint8_t>(0xEFu) && byte1 == static_cast<uint8_t>(0xBBu) &&
        byte2 == static_cast<uint8_t>(0xBFu)) {
        has_bom = true;
        return utf_encode_t::UTF_8;
    }

    if (byte0 == 0 && byte1 == 0 && byte2 == static_cast<uint8_t>(0xFEu) && byte3 == static_cast<uint8_t>(0xFFu)) {
        has_bom = true;
        return utf_encode_t::UTF_32BE;
    }

    if (byte0 == static_cast<uint8_t>(0xFFu) && byte1 == static_cast<uint8_t>(0xFEu) && byte2 == 0 && byte3 == 0) {
        has_bom = true;
        return utf_encode_t::UTF_32LE;
    }

    if (byte0 == static_cast<uint8_t>(0xFEu) && byte1 == static_cast<uint8_t>(0xFFu)) {
        has_bom = true;
        return utf_encode_t::UTF_16BE;
    }

    if (byte0 == static_cast<uint8_t>(0xFFu) && byte1 == static_cast<uint8_t>(0xFEu)) {
        has_bom = true;
        return utf_encode_t::UTF_16LE;
    }

    // Test the first character assuming it's an ASCII character.

    if (byte0 == 0 && byte1 == 0 && byte2 == 0 && 0 < byte3 && byte3 < static_cast<uint8_t>(0x80u)) {
        return utf_encode_t::UTF_32BE;
    }

    if (0 < byte0 && byte0 < static_cast<uint8_t>(0x80u) && byte1 == 0 && byte2 == 0 && byte3 == 0) {
        return utf_encode_t::UTF_32LE;
    }

    if (byte0 == 0 && 0 < byte1 && byte1 < static_cast<uint8_t>(0x80u)) {
        return utf_encode_t::UTF_16BE;
    }

    if (0 < byte0 && byte0 < static_cast<uint8_t>(0x80u) && byte1 == 0) {
        return utf_encode_t::UTF_16LE;
    }

    return utf_encode_t::UTF_8;
}

/// @brief A class which detects UTF encoding type and the existence of a BOM at the beginning.
/// @tparam ItrType Type of iterators for the input.
template <typename ItrType, typename = void>
struct utf_encode_detector {};

/// @brief The partial specialization of utf_encode_detector for char iterators.
/// @tparam ItrType An iterator type.
template <typename ItrType>
struct utf_encode_detector<ItrType, enable_if_t<is_iterator_of<ItrType, char>::value>> {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param begin The iterator to the first element of an input.
    /// @param end The iterator to the past-the end element of an input.
    /// @return A detected encoding type.
    static utf_encode_t detect(ItrType& begin, const ItrType& end) noexcept {
        if FK_YAML_UNLIKELY (begin == end) {
            return utf_encode_t::UTF_8;
        }

        // the inner curly braces are necessary for older compilers
        std::array<uint8_t, 4> bytes {{}};
        bytes.fill(0xFFu);
        auto current = begin;
        for (int i = 0; i < 4 && current != end; i++, ++current) {
            bytes[i] = static_cast<uint8_t>(*current); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        if (has_bom) {
            // skip reading the BOM.
            switch (encode_type) {
            case utf_encode_t::UTF_8:
                std::advance(begin, 3);
                break;
            case utf_encode_t::UTF_16BE:
            case utf_encode_t::UTF_16LE:
                std::advance(begin, 2);
                break;
            case utf_encode_t::UTF_32BE:
            case utf_encode_t::UTF_32LE:
                std::advance(begin, 4);
                break;
            }
        }

        return encode_type;
    }
};

#if FK_YAML_HAS_CHAR8_T

/// @brief The partial specialization of utf_encode_detector for char8_t iterators.
/// @tparam ItrType An iterator type.
template <typename ItrType>
struct utf_encode_detector<ItrType, enable_if_t<is_iterator_of<ItrType, char8_t>::value>> {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param begin The iterator to the first element of an input.
    /// @param end The iterator to the past-the end element of an input.
    /// @return A detected encoding type.
    static utf_encode_t detect(ItrType& begin, const ItrType& end) {
        if FK_YAML_UNLIKELY (begin == end) {
            return utf_encode_t::UTF_8;
        }

        std::array<uint8_t, 4> bytes {};
        bytes.fill(0xFFu);
        auto current = begin;
        for (int i = 0; i < 4 && current != end; i++, ++current) {
            bytes[i] = uint8_t(*current); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        if FK_YAML_UNLIKELY (encode_type != utf_encode_t::UTF_8) {
            throw exception("char8_t characters must be encoded in the UTF-8 format.");
        }

        if (has_bom) {
            // skip reading the BOM.
            std::advance(begin, 3);
        }

        return encode_type;
    }
};

#endif // FK_YAML_HAS_CHAR8_T

/// @brief The partial specialization of utf_encode_detector for char16_t iterators.
/// @tparam ItrType An iterator type.
template <typename ItrType>
struct utf_encode_detector<ItrType, enable_if_t<is_iterator_of<ItrType, char16_t>::value>> {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param begin The iterator to the first element of an input.
    /// @param end The iterator to the past-the end element of an input.
    /// @return A detected encoding type.
    static utf_encode_t detect(ItrType& begin, const ItrType& end) {
        if FK_YAML_UNLIKELY (begin == end) {
            return utf_encode_t::UTF_16BE;
        }

        // the inner curly braces are necessary for older compilers
        std::array<uint8_t, 4> bytes {{}};
        bytes.fill(0xFFu);
        auto current = begin;
        for (int i = 0; i < 2 && current != end; i++, ++current) {
            // NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
            const char16_t elem = *current;
            const int idx_base = i * 2;
            bytes[idx_base] = static_cast<uint8_t>(elem >> 8);
            bytes[idx_base + 1] = static_cast<uint8_t>(elem);
            // NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        if FK_YAML_UNLIKELY (encode_type != utf_encode_t::UTF_16BE && encode_type != utf_encode_t::UTF_16LE) {
            throw exception("char16_t characters must be encoded in the UTF-16 format.");
        }

        if (has_bom) {
            // skip reading the BOM.
            std::advance(begin, 1);
        }

        return encode_type;
    }
};

/// @brief The partial specialization of utf_encode_detector for char32_t iterators.
/// @tparam ItrType An iterator type.
template <typename ItrType>
struct utf_encode_detector<ItrType, enable_if_t<is_iterator_of<ItrType, char32_t>::value>> {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param begin The iterator to the first element of an input.
    /// @param end The iterator to the past-the end element of an input.
    /// @return A detected encoding type.
    static utf_encode_t detect(ItrType& begin, const ItrType& end) {
        if FK_YAML_UNLIKELY (begin == end) {
            return utf_encode_t::UTF_32BE;
        }

        // the inner curly braces are necessary for older compilers
        std::array<uint8_t, 4> bytes {{}};
        const char32_t elem = *begin;
        bytes[0] = static_cast<uint8_t>(elem >> 24);
        bytes[1] = static_cast<uint8_t>(elem >> 16);
        bytes[2] = static_cast<uint8_t>(elem >> 8);
        bytes[3] = static_cast<uint8_t>(elem);

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        if FK_YAML_UNLIKELY (encode_type != utf_encode_t::UTF_32BE && encode_type != utf_encode_t::UTF_32LE) {
            throw exception("char32_t characters must be encoded in the UTF-32 format.");
        }

        if (has_bom) {
            // skip reading the BOM.
            std::advance(begin, 1);
        }

        return encode_type;
    }
};

/// @brief A class which detects UTF encoding type and the existence of a BOM from the input file.
struct file_utf_encode_detector {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param p_file The input file handle.
    /// @return A detected encoding type.
    static utf_encode_t detect(std::FILE* p_file) noexcept {
        // the inner curly braces are necessary for older compilers
        std::array<uint8_t, 4> bytes {{}};
        bytes.fill(0xFFu);
        for (int i = 0; i < 4; i++) {
            char byte = 0;
            const std::size_t size = std::fread(&byte, sizeof(char), 1, p_file);
            if (size != sizeof(char)) {
                break;
            }
            bytes[i] = static_cast<uint8_t>(byte & 0xFF); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        // move back to the beginning if a BOM doesn't exist.
        long offset = 0; // NOLINT(google-runtime-int)
        if (has_bom) {
            switch (encode_type) {
            case utf_encode_t::UTF_8:
                offset = 3;
                break;
            case utf_encode_t::UTF_16BE:
            case utf_encode_t::UTF_16LE:
                offset = 2;
                break;
            case utf_encode_t::UTF_32BE:
            case utf_encode_t::UTF_32LE:
                offset = 4;
                break;
            }
        }
        std::fseek(p_file, offset, SEEK_SET); // NOLINT(cert-err33-c)

        return encode_type;
    }
};

/// @brief A class which detects UTF encoding type and the existence of a BOM from the input file.
struct stream_utf_encode_detector {
    /// @brief Detects the encoding type of the input, and consumes a BOM if it exists.
    /// @param p_file The input file handle.
    /// @return A detected encoding type.
    static utf_encode_t detect(std::istream& is) noexcept {
        // the inner curly braces are necessary for older compilers
        std::array<uint8_t, 4> bytes {{}};
        bytes.fill(0xFFu);
        for (int i = 0; i < 4; i++) {
            char ch = 0;
            is.read(&ch, 1);
            const std::streamsize size = is.gcount();
            if (size != 1) {
                // without this, seekg() will fail.
                is.clear();
                break;
            }
            bytes[i] = static_cast<uint8_t>(ch & 0xFF); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        bool has_bom = false;
        const utf_encode_t encode_type = detect_encoding_type(bytes, has_bom);

        // move back to the beginning if a BOM doesn't exist.
        std::streamoff offset = 0;
        if (has_bom) {
            switch (encode_type) {
            case utf_encode_t::UTF_8:
                offset = 3;
                break;
            case utf_encode_t::UTF_16BE:
            case utf_encode_t::UTF_16LE:
                offset = 2;
                break;
            case utf_encode_t::UTF_32BE:
            case utf_encode_t::UTF_32LE:
                offset = 4;
                break;
            }
        }
        is.seekg(offset, std::ios_base::beg);

        return encode_type;
    }
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_DETECTOR_HPP */

// #include <fkYAML/detail/encodings/utf_encode_t.hpp>

// #include <fkYAML/detail/encodings/utf_encodings.hpp>

// #include <fkYAML/detail/meta/input_adapter_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/str_view.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

///////////////////////
//   input_adapter   //
///////////////////////

template <typename IterType, typename = void>
class iterator_input_adapter;

/// @brief An input adapter for iterators of type char.
/// @tparam IterType An iterator type.
template <typename IterType>
class iterator_input_adapter<IterType, enable_if_t<is_iterator_of<IterType, char>::value>> {
public:
    /// @brief Construct a new iterator_input_adapter object.
    iterator_input_adapter() = default;

    /// @brief Construct a new iterator_input_adapter object.
    /// @param begin The beginning of iterators.
    /// @param end The end of iterators.
    /// @param encode_type The encoding type for this input adapter.
    /// @param is_contiguous Whether iterators are contiguous or not.
    iterator_input_adapter(IterType begin, IterType end, utf_encode_t encode_type, bool is_contiguous) noexcept
        : m_begin(begin),
          m_end(end),
          m_encode_type(encode_type),
          m_is_contiguous(is_contiguous) {
    }

    // allow only move construct/assignment like other input adapters.
    iterator_input_adapter(const iterator_input_adapter&) = delete;
    iterator_input_adapter(iterator_input_adapter&& rhs) = default;
    iterator_input_adapter& operator=(const iterator_input_adapter&) = delete;
    iterator_input_adapter& operator=(iterator_input_adapter&&) = default;
    ~iterator_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        if FK_YAML_UNLIKELY (m_begin == m_end) {
            return {};
        }

        m_buffer.clear();

        switch (m_encode_type) {
        case utf_encode_t::UTF_8:
            return get_buffer_view_utf8();
        case utf_encode_t::UTF_16BE:
        case utf_encode_t::UTF_16LE:
            return get_buffer_view_utf16();
        case utf_encode_t::UTF_32BE:
        case utf_encode_t::UTF_32LE:
            return get_buffer_view_utf32();
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }
    }

private:
    /// @brief The concrete implementation of get_buffer_view() for UTF-8 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf8() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_8);

        IterType current = m_begin;
        std::deque<IterType> cr_itrs {};
        while (current != m_end) {
            const auto first = static_cast<uint8_t>(*current);
            const uint32_t num_bytes = utf8::get_num_bytes(first);

            switch (num_bytes) {
            case 1:
                if FK_YAML_UNLIKELY (first == 0x0D /*CR*/) {
                    cr_itrs.emplace_back(current);
                }
                break;
            case 2: {
                const auto second = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second});
                }
                break;
            }
            case 3: {
                const auto second = static_cast<uint8_t>(*++current);
                const auto third = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second, third);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third});
                }
                break;
            }
            case 4: {
                const auto second = static_cast<uint8_t>(*++current);
                const auto third = static_cast<uint8_t>(*++current);
                const auto fourth = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second, third, fourth);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third, fourth});
                }
                break;
            }
            default:           // LCOV_EXCL_LINE
                unreachable(); // LCOV_EXCL_LINE
            }

            ++current;
        }

        const bool is_contiguous_no_cr = cr_itrs.empty() && m_is_contiguous;
        if FK_YAML_LIKELY (is_contiguous_no_cr) {
            // The input iterators (begin, end) can be used as-is during parsing.
            FK_YAML_ASSERT(m_begin != m_end);
            return str_view {&*m_begin, static_cast<std::size_t>(std::distance(m_begin, m_end))};
        }

        m_buffer.reserve(std::distance(m_begin, m_end) - cr_itrs.size());

        current = m_begin;
        for (const auto& cr_itr : cr_itrs) {
            m_buffer.append(current, cr_itr);
            current = std::next(cr_itr);
        }
        m_buffer.append(current, m_end);

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-16 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf16() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_16BE || m_encode_type == utf_encode_t::UTF_16LE);

        // Assume the input characters are all ASCII characters.
        // That's the most probably the case.
        m_buffer.reserve(std::distance(m_begin, m_end) / 2);

        int shift_bits[2] {0, 0};
        if (m_encode_type == utf_encode_t::UTF_16BE) {
            shift_bits[0] = 8;
        }
        else // m_encode_type == utf_encode_t::UTF_16LE
        {
            shift_bits[1] = 8;
        }

        std::array<char16_t, 2> encoded_buffer {{0, 0}};
        uint32_t encoded_buf_size {0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        IterType current = m_begin;
        while (current != m_end || encoded_buf_size != 0) {
            while (current != m_end && encoded_buf_size < 2) {
                auto utf16 = static_cast<char16_t>(static_cast<uint8_t>(*current) << shift_bits[0]);
                utf16 |= static_cast<char16_t>(static_cast<uint8_t>(*++current) << shift_bits[1]);
                ++current;

                // skip appending CRs.
                if FK_YAML_LIKELY (utf16 != char16_t(0x000Du)) {
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                    encoded_buffer[encoded_buf_size++] = utf16;
                }
            }

            uint32_t consumed_size = 0;
            utf8::from_utf16(encoded_buffer, utf8_buffer, consumed_size, utf8_buf_size);

            if FK_YAML_LIKELY (consumed_size == 1) {
                encoded_buffer[0] = encoded_buffer[1];
            }
            encoded_buf_size -= consumed_size;

            m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-32 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf32() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_32BE || m_encode_type == utf_encode_t::UTF_32LE);

        // Assume the input characters are all ASCII characters.
        // That's the most probably the case.
        m_buffer.reserve(std::distance(m_begin, m_end) / 4);

        int shift_bits[4] {0, 0, 0, 0};
        if (m_encode_type == utf_encode_t::UTF_32BE) {
            shift_bits[0] = 24;
            shift_bits[1] = 16;
            shift_bits[2] = 8;
        }
        else // m_encode_type == utf_encode_t::UTF_32LE
        {
            shift_bits[1] = 8;
            shift_bits[2] = 16;
            shift_bits[3] = 24;
        }

        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        IterType current = m_begin;
        while (current != m_end) {
            auto utf32 = static_cast<char32_t>(*current << shift_bits[0]);
            ++current;
            utf32 |= static_cast<char32_t>(*current << shift_bits[1]);
            ++current;
            utf32 |= static_cast<char32_t>(*current << shift_bits[2]);
            ++current;
            utf32 |= static_cast<char32_t>(*current << shift_bits[3]);
            ++current;

            if FK_YAML_LIKELY (utf32 != char32_t(0x0000000Du)) {
                utf8::from_utf32(utf32, utf8_buffer, utf8_buf_size);
                m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
            }
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// The iterator at the beginning of input.
    IterType m_begin {};
    /// The iterator at the end of input.
    IterType m_end {};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_8};
    /// The normalized owned buffer.
    std::string m_buffer;
    /// Whether ItrType is a contiguous iterator.
    bool m_is_contiguous {false};
};

#if FK_YAML_HAS_CHAR8_T

/// @brief An input adapter for iterators of type char8_t.
/// @tparam IterType An iterator type.
template <typename IterType>
class iterator_input_adapter<IterType, enable_if_t<is_iterator_of<IterType, char8_t>::value>> {
public:
    /// @brief Construct a new iterator_input_adapter object.
    iterator_input_adapter() = default;

    /// @brief Construct a new iterator_input_adapter object.
    /// @param begin The beginning of iterators.
    /// @param end The end of iterators.
    /// @param encode_type The encoding type for this input adapter.
    /// @param is_contiguous Whether iterators are contiguous or not.
    iterator_input_adapter(IterType begin, IterType end, utf_encode_t encode_type, bool is_contiguous) noexcept
        : m_begin(begin),
          m_end(end),
          m_encode_type(encode_type),
          m_is_contiguous(is_contiguous) {
        // char8_t characters must be encoded in the UTF-8 format.
        // See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0482r6.html.
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_8);
    }

    // allow only move construct/assignment like other input adapters.
    iterator_input_adapter(const iterator_input_adapter&) = delete;
    iterator_input_adapter(iterator_input_adapter&& rhs) = default;
    iterator_input_adapter& operator=(const iterator_input_adapter&) = delete;
    iterator_input_adapter& operator=(iterator_input_adapter&&) = default;
    ~iterator_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        if FK_YAML_UNLIKELY (m_begin == m_end) {
            return {};
        }

        IterType current = m_begin;
        std::deque<IterType> cr_itrs {};
        while (current != m_end) {
            const auto first = static_cast<uint8_t>(*current);
            const uint32_t num_bytes = utf8::get_num_bytes(first);

            switch (num_bytes) {
            case 1:
                if FK_YAML_UNLIKELY (first == 0x0D /*CR*/) {
                    cr_itrs.emplace_back(current);
                }
                break;
            case 2: {
                const auto second = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second});
                }
                break;
            }
            case 3: {
                const auto second = static_cast<uint8_t>(*++current);
                const auto third = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second, third);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third});
                }
                break;
            }
            case 4: {
                const auto second = static_cast<uint8_t>(*++current);
                const auto third = static_cast<uint8_t>(*++current);
                const auto fourth = static_cast<uint8_t>(*++current);
                const bool is_valid = utf8::validate(first, second, third, fourth);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third, fourth});
                }
                break;
            }
            default:           // LCOV_EXCL_LINE
                unreachable(); // LCOV_EXCL_LINE
            }

            ++current;
        }

        m_buffer.reserve(std::distance(m_begin, m_end) - cr_itrs.size());
        current = m_begin;
        for (const auto& cr_itr : cr_itrs) {
            std::transform(
                current, cr_itr, std::back_inserter(m_buffer), [](char8_t c) { return static_cast<char>(c); });
            current = std::next(cr_itr);
        }
        std::transform(current, m_end, std::back_inserter(m_buffer), [](char8_t c) { return static_cast<char>(c); });

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// The iterator at the beginning of input.
    IterType m_begin {};
    /// The iterator at the end of input.
    IterType m_end {};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_8};
    /// The normalized owned buffer.
    std::string m_buffer;
    /// Whether ItrType is a contiguous iterator.
    bool m_is_contiguous {false};
};

#endif // FK_YAML_HAS_CHAR8_T

/// @brief An input adapter for iterators of type char16_t.
/// @tparam IterType An iterator type.
template <typename IterType>
class iterator_input_adapter<IterType, enable_if_t<is_iterator_of<IterType, char16_t>::value>> {
public:
    /// @brief Construct a new iterator_input_adapter object.
    iterator_input_adapter() = default;

    /// @brief Construct a new iterator_input_adapter object.
    /// @param begin The beginning of iterators.
    /// @param end The end of iterators.
    /// @param encode_type The encoding type for this input adapter.
    /// @param is_contiguous Whether iterators are contiguous or not.
    iterator_input_adapter(IterType begin, IterType end, utf_encode_t encode_type, bool is_contiguous) noexcept
        : m_begin(begin),
          m_end(end),
          m_encode_type(encode_type),
          m_is_contiguous(is_contiguous) {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_16BE || m_encode_type == utf_encode_t::UTF_16LE);
    }

    // allow only move construct/assignment like other input adapters.
    iterator_input_adapter(const iterator_input_adapter&) = delete;
    iterator_input_adapter(iterator_input_adapter&& rhs) = default;
    iterator_input_adapter& operator=(const iterator_input_adapter&) = delete;
    iterator_input_adapter& operator=(iterator_input_adapter&&) = default;
    ~iterator_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        if FK_YAML_UNLIKELY (m_begin == m_end) {
            return {};
        }

        const int shift_bits = (m_encode_type == utf_encode_t::UTF_16BE) ? 0 : 8;

        std::array<char16_t, 2> encoded_buffer {{0, 0}};
        uint32_t encoded_buf_size {0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        // Assume the input characters are all ASCII characters.
        // That's the most probably the case.
        m_buffer.reserve(std::distance(m_begin, m_end));

        IterType current = m_begin;
        while (current != m_end || encoded_buf_size != 0) {
            while (current != m_end && encoded_buf_size < 2) {
                char16_t utf16 = *current;
                ++current;
                utf16 = static_cast<char16_t>(((utf16 & 0x00FFu) << shift_bits) | ((utf16 & 0xFF00u) >> shift_bits));

                if FK_YAML_LIKELY (utf16 != char16_t(0x000Du)) {
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                    encoded_buffer[encoded_buf_size++] = utf16;
                }
            }

            uint32_t consumed_size = 0;
            utf8::from_utf16(encoded_buffer, utf8_buffer, consumed_size, utf8_buf_size);

            if FK_YAML_LIKELY (consumed_size == 1) {
                encoded_buffer[0] = encoded_buffer[1];
                encoded_buffer[1] = 0;
            }
            encoded_buf_size -= consumed_size;

            m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// The iterator at the beginning of input.
    IterType m_begin {};
    /// The iterator at the end of input.
    IterType m_end {};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_16BE};
    /// The normalized owned buffer.
    std::string m_buffer;
    /// Whether ItrType is a contiguous iterator.
    bool m_is_contiguous {false};
};

/// @brief An input adapter for iterators of type char32_t.
/// @tparam IterType An iterator type.
template <typename IterType>
class iterator_input_adapter<IterType, enable_if_t<is_iterator_of<IterType, char32_t>::value>> {
public:
    /// @brief Construct a new iterator_input_adapter object.
    iterator_input_adapter() = default;

    /// @brief Construct a new iterator_input_adapter object.
    /// @param begin The beginning of iterators.
    /// @param end The end of iterators.
    /// @param encode_type The encoding type for this input adapter.
    /// @param is_contiguous Whether iterators are contiguous or not.
    iterator_input_adapter(IterType begin, IterType end, utf_encode_t encode_type, bool is_contiguous) noexcept
        : m_begin(begin),
          m_end(end),
          m_encode_type(encode_type),
          m_is_contiguous(is_contiguous) {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_32BE || m_encode_type == utf_encode_t::UTF_32LE);
    }

    // allow only move construct/assignment like other input adapters.
    iterator_input_adapter(const iterator_input_adapter&) = delete;
    iterator_input_adapter(iterator_input_adapter&& rhs) = default;
    iterator_input_adapter& operator=(const iterator_input_adapter&) = delete;
    iterator_input_adapter& operator=(iterator_input_adapter&&) = default;
    ~iterator_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        if FK_YAML_UNLIKELY (m_begin == m_end) {
            return {};
        }

        int shift_bits[4] {0, 0, 0, 0};
        if (m_encode_type == utf_encode_t::UTF_32LE) {
            shift_bits[0] = 24;
            shift_bits[1] = 8;
            shift_bits[2] = 8;
            shift_bits[3] = 24;
        }

        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        // Assume the input characters are all ASCII characters.
        // That's the most probably the case.
        m_buffer.reserve(std::distance(m_begin, m_end));

        IterType current = m_begin;
        while (current != m_end) {
            const char32_t tmp = *current;
            ++current;
            const auto utf32 = static_cast<char32_t>(
                ((tmp & 0xFF000000u) >> shift_bits[0]) | ((tmp & 0x00FF0000u) >> shift_bits[1]) |
                ((tmp & 0x0000FF00u) << shift_bits[2]) | ((tmp & 0x000000FFu) << shift_bits[3]));

            if FK_YAML_UNLIKELY (utf32 != static_cast<char32_t>(0x0000000Du)) {
                utf8::from_utf32(utf32, utf8_buffer, utf8_buf_size);
                m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
            }
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// The iterator at the beginning of input.
    IterType m_begin {};
    /// The iterator at the end of input.
    IterType m_end {};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_32BE};
    /// The normalized owned buffer.
    std::string m_buffer;
    /// Whether ItrType is a contiguous iterator.
    bool m_is_contiguous {false};
};

/// @brief An input adapter for C-style file handles.
class file_input_adapter {
public:
    /// @brief Construct a new file_input_adapter object.
    file_input_adapter() = default;

    /// @brief Construct a new file_input_adapter object.
    /// @note
    /// This class doesn't call fopen() nor fclose().
    /// It's user's responsibility to call those functions.
    /// @param file A file handle for this adapter. (A non-null pointer is assumed.)
    /// @param encode_type The encoding type for this input adapter.
    explicit file_input_adapter(std::FILE* file, utf_encode_t encode_type) noexcept
        : m_file(file),
          m_encode_type(encode_type) {
    }

    // allow only move construct/assignment
    file_input_adapter(const file_input_adapter&) = delete;
    file_input_adapter(file_input_adapter&& rhs) = default;
    file_input_adapter& operator=(const file_input_adapter&) = delete;
    file_input_adapter& operator=(file_input_adapter&&) = default;
    ~file_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        switch (m_encode_type) {
        case utf_encode_t::UTF_8:
            return get_buffer_view_utf8();
        case utf_encode_t::UTF_16BE:
        case utf_encode_t::UTF_16LE:
            return get_buffer_view_utf16();
        case utf_encode_t::UTF_32BE:
        case utf_encode_t::UTF_32LE:
            return get_buffer_view_utf32();
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }
    }

private:
    /// @brief The concrete implementation of get_buffer_view() for UTF-8 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf8() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_8);

        m_buffer.clear();
        char tmp_buf[256] {};
        constexpr std::size_t buf_size = sizeof(tmp_buf) / sizeof(tmp_buf[0]);
        std::size_t read_size = 0;
        while ((read_size = std::fread(&tmp_buf[0], sizeof(char), buf_size, m_file)) > 0) {
            char* p_current = &tmp_buf[0];
            char* p_end = p_current + read_size;

            // copy tmp_buf to m_buffer, dropping CRs.
            char* p_cr = p_current;
            do {
                if FK_YAML_UNLIKELY (*p_cr == '\r') {
                    m_buffer.append(p_current, p_cr);
                    p_current = p_cr + 1;
                }
                ++p_cr;
            } while (p_cr != p_end);

            m_buffer.append(p_current, p_end);
        }

        if FK_YAML_UNLIKELY (m_buffer.empty()) {
            return {};
        }

        auto current = m_buffer.begin();
        auto end = m_buffer.end();
        while (current != end) {
            const auto first = static_cast<uint8_t>(*current++);
            const uint32_t num_bytes = utf8::get_num_bytes(first);

            switch (num_bytes) {
            case 1:
                break;
            case 2: {
                const auto second = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second});
                }
                break;
            }
            case 3: {
                const auto second = static_cast<uint8_t>(*current++);
                const auto third = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second, third);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third});
                }
                break;
            }
            case 4: {
                const auto second = static_cast<uint8_t>(*current++);
                const auto third = static_cast<uint8_t>(*current++);
                const auto fourth = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second, third, fourth);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third, fourth});
                }
                break;
            }
            default:           // LCOV_EXCL_LINE
                unreachable(); // LCOV_EXCL_LINE
            }
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-16 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf16() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_16BE || m_encode_type == utf_encode_t::UTF_16LE);

        int shift_bits[2] {0, 0};
        if (m_encode_type == utf_encode_t::UTF_16BE) {
            shift_bits[0] = 8;
        }
        else { // m_encode_type == utf_encode_t::UTF_16LE
            shift_bits[1] = 8;
        }

        char chars[2] = {0, 0};
        std::array<char16_t, 2> encoded_buffer {{0, 0}};
        uint32_t encoded_buf_size {0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        while (std::feof(m_file) == 0) {
            while (encoded_buf_size < 2 && std::fread(&chars[0], sizeof(char), 2, m_file) == 2) {
                const auto utf16 = static_cast<char16_t>(
                    (static_cast<uint8_t>(chars[0]) << shift_bits[0]) |
                    (static_cast<uint8_t>(chars[1]) << shift_bits[1]));
                if FK_YAML_LIKELY (utf16 != static_cast<char16_t>(0x000Du)) {
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                    encoded_buffer[encoded_buf_size++] = utf16;
                }
            }

            uint32_t consumed_size = 0;
            utf8::from_utf16(encoded_buffer, utf8_buffer, consumed_size, utf8_buf_size);

            if FK_YAML_LIKELY (consumed_size == 1) {
                encoded_buffer[0] = encoded_buffer[1];
            }
            encoded_buf_size -= consumed_size;

            m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-32 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf32() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_32BE || m_encode_type == utf_encode_t::UTF_32LE);

        int shift_bits[4] {0, 0, 0, 0};
        if (m_encode_type == utf_encode_t::UTF_32BE) {
            shift_bits[0] = 24;
            shift_bits[1] = 16;
            shift_bits[2] = 8;
        }
        else { // m_encode_type == utf_encode_t::UTF_32LE
            shift_bits[1] = 8;
            shift_bits[2] = 16;
            shift_bits[3] = 24;
        }

        char chars[4] = {0, 0, 0, 0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        while (std::feof(m_file) == 0) {
            const std::size_t size = std::fread(&chars[0], sizeof(char), 4, m_file);
            if (size != 4) {
                break;
            }

            const auto utf32 = static_cast<char32_t>(
                (static_cast<uint8_t>(chars[0]) << shift_bits[0]) | (static_cast<uint8_t>(chars[1]) << shift_bits[1]) |
                (static_cast<uint8_t>(chars[2]) << shift_bits[2]) | (static_cast<uint8_t>(chars[3]) << shift_bits[3]));

            if FK_YAML_LIKELY (utf32 != char32_t(0x0000000Du)) {
                utf8::from_utf32(utf32, utf8_buffer, utf8_buf_size);
                m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
            }
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// A pointer to the input file handle.
    std::FILE* m_file {nullptr};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_8};
    /// The normalized owned buffer.
    std::string m_buffer;
};

/// @brief An input adapter for streams
class stream_input_adapter {
public:
    /// @brief Construct a new stream_input_adapter object.
    stream_input_adapter() = default;

    /// @brief Construct a new stream_input_adapter object.
    /// @param is A reference to the target input stream.
    /// @param encode_type The encoding type for this input adapter.
    explicit stream_input_adapter(std::istream& is, utf_encode_t encode_type) noexcept
        : m_istream(&is),
          m_encode_type(encode_type) {
    }

    // allow only move construct/assignment
    stream_input_adapter(const stream_input_adapter&) = delete;
    stream_input_adapter& operator=(const stream_input_adapter&) = delete;
    stream_input_adapter(stream_input_adapter&&) = default;
    stream_input_adapter& operator=(stream_input_adapter&&) = default;
    ~stream_input_adapter() = default;

    /// @brief Get view into the input buffer contents.
    /// @return View into the input buffer contents.
    str_view get_buffer_view() {
        switch (m_encode_type) {
        case utf_encode_t::UTF_8:
            return get_buffer_view_utf8();
        case utf_encode_t::UTF_16BE:
        case utf_encode_t::UTF_16LE:
            return get_buffer_view_utf16();
        case utf_encode_t::UTF_32BE:
        case utf_encode_t::UTF_32LE:
            return get_buffer_view_utf32();
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }
    }

private:
    /// @brief The concrete implementation of get_buffer_view() for UTF-8 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf8() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_8);

        m_buffer.clear();
        char tmp_buf[256] {};
        do {
            m_istream->read(&tmp_buf[0], 256);
            const auto read_size = static_cast<std::size_t>(m_istream->gcount());
            if FK_YAML_UNLIKELY (read_size == 0) {
                break;
            }

            char* p_current = &tmp_buf[0];
            char* p_end = p_current + read_size;

            // copy tmp_buf to m_buffer, dropping CRs.
            char* p_cr = p_current;
            do {
                if FK_YAML_UNLIKELY (*p_cr == '\r') {
                    m_buffer.append(p_current, p_cr);
                    p_current = p_cr + 1;
                }
                ++p_cr;
            } while (p_cr != p_end);

            m_buffer.append(p_current, p_end);
        } while (!m_istream->eof());

        if FK_YAML_UNLIKELY (m_buffer.empty()) {
            return {};
        }

        auto current = m_buffer.begin();
        auto end = m_buffer.end();
        while (current != end) {
            const auto first = static_cast<uint8_t>(*current++);
            const uint32_t num_bytes = utf8::get_num_bytes(first);

            switch (num_bytes) {
            case 1:
                break;
            case 2: {
                const auto second = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second});
                }
                break;
            }
            case 3: {
                const auto second = static_cast<uint8_t>(*current++);
                const auto third = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second, third);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third});
                }
                break;
            }
            case 4: {
                const auto second = static_cast<uint8_t>(*current++);
                const auto third = static_cast<uint8_t>(*current++);
                const auto fourth = static_cast<uint8_t>(*current++);
                const bool is_valid = utf8::validate(first, second, third, fourth);
                if FK_YAML_UNLIKELY (!is_valid) {
                    throw fkyaml::invalid_encoding("Invalid UTF-8 encoding.", {first, second, third, fourth});
                }
                break;
            }
            default:           // LCOV_EXCL_LINE
                unreachable(); // LCOV_EXCL_LINE
            }
        }

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-16 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf16() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_16BE || m_encode_type == utf_encode_t::UTF_16LE);

        int shift_bits[2] {0, 0};
        if (m_encode_type == utf_encode_t::UTF_16BE) {
            shift_bits[0] = 8;
        }
        else { // m_encode_type == utf_encode_t::UTF_16LE
            shift_bits[1] = 8;
        }

        char chars[2] = {0, 0};
        std::array<char16_t, 2> encoded_buffer {{0, 0}};
        uint32_t encoded_buf_size {0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        do {
            while (encoded_buf_size < 2) {
                m_istream->read(&chars[0], 2);
                const std::streamsize size = m_istream->gcount();
                if FK_YAML_UNLIKELY (size != 2) {
                    break;
                }

                const auto utf16 = static_cast<char16_t>(
                    (static_cast<uint8_t>(chars[0]) << shift_bits[0]) |
                    (static_cast<uint8_t>(chars[1]) << shift_bits[1]));

                if FK_YAML_LIKELY (utf16 != static_cast<char16_t>(0x000Du)) {
                    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                    encoded_buffer[encoded_buf_size++] = utf16;
                }
            }

            uint32_t consumed_size = 0;
            utf8::from_utf16(encoded_buffer, utf8_buffer, consumed_size, utf8_buf_size);

            if FK_YAML_LIKELY (consumed_size == 1) {
                encoded_buffer[0] = encoded_buffer[1];
            }
            encoded_buf_size -= consumed_size;

            m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
        } while (!m_istream->eof());

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

    /// @brief The concrete implementation of get_buffer_view() for UTF-32 encoded inputs.
    /// @return View into the UTF-8 encoded input buffer contents.
    str_view get_buffer_view_utf32() {
        FK_YAML_ASSERT(m_encode_type == utf_encode_t::UTF_32BE || m_encode_type == utf_encode_t::UTF_32LE);

        int shift_bits[4] {0, 0, 0, 0};
        if (m_encode_type == utf_encode_t::UTF_32BE) {
            shift_bits[0] = 24;
            shift_bits[1] = 16;
            shift_bits[2] = 8;
        }
        else { // m_encode_type == utf_encode_t::UTF_32LE
            shift_bits[1] = 8;
            shift_bits[2] = 16;
            shift_bits[3] = 24;
        }

        char chars[4] = {0, 0, 0, 0};
        std::array<uint8_t, 4> utf8_buffer {{0, 0, 0, 0}};
        uint32_t utf8_buf_size {0};

        do {
            m_istream->read(&chars[0], 4);
            const std::streamsize size = m_istream->gcount();
            if FK_YAML_UNLIKELY (size != 4) {
                break;
            }

            const auto utf32 = static_cast<char32_t>(
                (static_cast<uint8_t>(chars[0]) << shift_bits[0]) | (static_cast<uint8_t>(chars[1]) << shift_bits[1]) |
                (static_cast<uint8_t>(chars[2]) << shift_bits[2]) | (static_cast<uint8_t>(chars[3]) << shift_bits[3]));

            if FK_YAML_LIKELY (utf32 != char32_t(0x0000000Du)) {
                utf8::from_utf32(utf32, utf8_buffer, utf8_buf_size);
                m_buffer.append(reinterpret_cast<const char*>(utf8_buffer.data()), utf8_buf_size);
            }
        } while (!m_istream->eof());

        return str_view {m_buffer.begin(), m_buffer.end()};
    }

private:
    /// A pointer to the input stream object.
    std::istream* m_istream {nullptr};
    /// The encoding type for this input adapter.
    utf_encode_t m_encode_type {utf_encode_t::UTF_8};
    /// The normalized owned buffer.
    std::string m_buffer;
};

/////////////////////////////////
//   input_adapter providers   //
/////////////////////////////////

/// @brief A concrete factory method for iterator_input_adapter objects with iterators.
/// @tparam ItrType An iterator type.
/// @param begin The beginning of iterators.
/// @param end The end of iterators.
/// @param is_contiguous Whether iterators refer to a contiguous byte array.
/// @return An iterator_input_adapter object for the target iterator type.
template <typename ItrType>
inline iterator_input_adapter<ItrType> create_iterator_input_adapter(ItrType begin, ItrType end, bool is_contiguous) {
    const utf_encode_t encode_type = utf_encode_detector<ItrType>::detect(begin, end);
    return iterator_input_adapter<ItrType>(begin, end, encode_type, is_contiguous);
}

/// @brief A factory method for iterator_input_adapter objects with iterator values.
/// @tparam ItrType An iterator type.
/// @param begin The beginning of iterators.
/// @param end The end of iterators.
/// @return iterator_input_adapter<ItrType> An iterator_input_adapter object for the target iterator type.
template <typename ItrType>
inline iterator_input_adapter<ItrType> input_adapter(ItrType begin, ItrType end) {
    bool is_contiguous = true;
    const auto size = std::distance(begin, end);

    // Check if `begin` & `end` are contiguous iterators.
    // Getting distance between begin and (end - 1) avoids dereferencing an invalid sentinel.
    if FK_YAML_LIKELY (size > 0) {
        using char_ptr_t = remove_cvref_t<typename std::iterator_traits<ItrType>::pointer>;
        char_ptr_t p_begin = &*begin;
        char_ptr_t p_second_last = &*std::next(begin, size - 1);
        is_contiguous = (p_second_last - p_begin == size);
    }
    return create_iterator_input_adapter(begin, end, is_contiguous);
}

/// @brief A factory method for iterator_input_adapter objects with C-style arrays.
/// @tparam T A type of arrayed objects.
/// @tparam N A size of an array.
/// @return decltype(input_adapter(array, array + N)) An iterator_input_adapter object for the target array.
template <typename T, std::size_t N>
inline auto input_adapter(T (&array)[N]) -> decltype(create_iterator_input_adapter(array, array + (N - 1), true)) {
    return create_iterator_input_adapter(array, array + (N - 1), true);
}

/// @brief A namespace to implement container_input_adapter_factory for internal use.
namespace input_adapter_factory {

using std::begin;
using std::end;

/// @brief A factory of input adapters for containers.
/// @tparam ContainerType A container type.
/// @tparam typename N/A
template <typename ContainerType, typename = void>
struct container_input_adapter_factory {};

/// @brief A partial specialization of container_input_adapter_factory if begin()/end() are available for ContainerType.
/// @tparam ContainerType A container type.
template <typename ContainerType>
struct container_input_adapter_factory<
    ContainerType, void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>> {
    /// A type for resulting input adapter object.
    using adapter_type =
        decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));

    /// @brief A factory method of input adapter objects for the target container objects.
    /// @param container A container-like input object.
    /// @return adapter_type An iterator_input_adapter object.
    static adapter_type create(const ContainerType& container) {
        return input_adapter(begin(container), end(container));
    }
};

} // namespace input_adapter_factory

/// @brief A factory method for iterator_input_adapter objects with containers.
/// @tparam ContainerType A container type.
/// @param container A container object.
/// @return input_adapter_factory::container_input_adapter_factory<ContainerType>::adapter_type
template <typename ContainerType>
inline typename input_adapter_factory::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(
    const ContainerType& container) {
    return input_adapter_factory::container_input_adapter_factory<ContainerType>::create(container);
}

/// @brief A factory method for file_input_adapter objects with C-style file handles.
/// @param file A file handle.
/// @return file_input_adapter A file_input_adapter object.
inline file_input_adapter input_adapter(std::FILE* file) {
    if FK_YAML_UNLIKELY (!file) {
        throw fkyaml::exception("Invalid FILE object pointer.");
    }

    const utf_encode_t encode_type = file_utf_encode_detector::detect(file);
    return file_input_adapter(file, encode_type);
}

/// @brief A factory method for stream_input_adapter objects with std::istream objects.
/// @param stream An input stream.
/// @return stream_input_adapter A stream_input_adapter object.
inline stream_input_adapter input_adapter(std::istream& stream) {
    if FK_YAML_UNLIKELY (!stream.good()) {
        throw fkyaml::exception("Invalid stream.");
    }

    const utf_encode_t encode_type = stream_utf_encode_detector::detect(stream);
    return stream_input_adapter(stream, encode_type);
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_INPUT_INPUT_ADAPTER_HPP */

// #include <fkYAML/detail/iterator.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_ITERATOR_HPP
#define FK_YAML_DETAIL_ITERATOR_HPP

#include <cstddef>
#include <iterator>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief The template definitions of type information used in @ref Iterator class
/// @tparam ValueType The type of iterated elements.
template <typename ValueType>
struct iterator_traits {
    /// A type of iterated elements.
    using value_type = typename ValueType::value_type;
    /// A type to represent difference between iterators.
    using difference_type = typename ValueType::difference_type;
    /// A type of an element pointer.
    using pointer = typename ValueType::pointer;
    /// A type of reference to an element.
    using reference = typename ValueType::reference;
};

/// @brief A specialization of @ref iterator_traits for constant value types.
/// @tparam ValueType The type of iterated elements.
template <typename ValueType>
struct iterator_traits<const ValueType> {
    /// A type of iterated elements.
    using value_type = typename ValueType::value_type;
    /// A type to represent difference between iterators.
    using difference_type = typename ValueType::difference_type;
    /// A type of a constant element pointer.
    using pointer = typename ValueType::const_pointer;
    /// A type of constant reference to an element.
    using reference = typename ValueType::const_reference;
};

/// @brief Definitions of iterator types for iterators internally held.
enum class iterator_t : std::uint8_t {
    SEQUENCE, //!< sequence iterator type.
    MAPPING,  //!< mapping iterator type.
};

/// @brief The actual storage for iterators internally held in iterator.
template <typename BasicNodeType>
struct iterator_holder {
    static_assert(
        is_basic_node<BasicNodeType>::value,
        "iterator_holder class only accepts a basic_node as its template parameter.");

    /// A sequence iterator object.
    typename BasicNodeType::sequence_type::iterator sequence_iterator {};
    /// A mapping iterator object.
    typename BasicNodeType::mapping_type::iterator mapping_iterator {};
};

/// @brief A class which holds iterators either of sequence or mapping type
/// @tparam ValueType The type of iterated elements.
template <typename ValueType>
class iterator {
    /// @brief The iterator type with ValueType of different const-ness.
    using other_iterator_type = typename std::conditional<
        std::is_const<ValueType>::value, iterator<typename std::remove_const<ValueType>::type>,
        iterator<const ValueType>>::type;

    friend other_iterator_type;

public:
    /// A type for iterator traits of instantiated @Iterator template class.
    using iterator_traits_type = iterator_traits<ValueType>;

    /// A type for iterator category tag.
    using iterator_category = std::bidirectional_iterator_tag;
    /// A type of iterated element.
    using value_type = typename iterator_traits_type::value_type;
    /// A type to represent differences between iterators.
    using difference_type = typename iterator_traits_type::difference_type;
    /// A type of an element pointer.
    using pointer = typename iterator_traits_type::pointer;
    /// A type of reference to an element.
    using reference = typename iterator_traits_type::reference;

    static_assert(is_basic_node<value_type>::value, "iterator class only accepts a basic_node as its value type.");

    /// @brief Constructs an iterator object.
    iterator() = default;

    /// @brief Construct a new iterator object with sequence iterator object.
    /// @param[in] itr An sequence iterator object.
    iterator(const typename value_type::sequence_type::iterator& itr) noexcept {
        m_iterator_holder.sequence_iterator = itr;
    }

    /// @brief Construct a new iterator object with mapping iterator object.
    /// @param[in] itr An mapping iterator object.
    iterator(const typename value_type::mapping_type::iterator& itr) noexcept
        : m_inner_iterator_type(iterator_t::MAPPING) {
        m_iterator_holder.mapping_iterator = itr;
    }

    /// @brief Copy constructs an iterator.
    iterator(const iterator&) = default;

    /// @brief Copy constructs an iterator from another iterator with different const-ness in ValueType.
    /// @note This copy constructor is not defined if ValueType is not const to avoid const removal from ValueType.
    /// @tparam OtherIterator The iterator type to copy from.
    /// @param other An iterator to copy from with different const-ness in ValueType.
    template <
        typename OtherIterator,
        enable_if_t<
            conjunction<std::is_same<OtherIterator, other_iterator_type>, std::is_const<ValueType>>::value, int> = 0>
    iterator(const OtherIterator& other) noexcept
        : m_inner_iterator_type(other.m_inner_iterator_type),
          m_iterator_holder(other.m_iterator_holder) {
    }

    /// @brief A copy assignment operator of the iterator class.
    iterator& operator=(const iterator&) = default;

    template <
        typename OtherIterator,
        enable_if_t<
            conjunction<std::is_same<OtherIterator, other_iterator_type>, std::is_const<ValueType>>::value, int> = 0>
    iterator& operator=(const OtherIterator& other) noexcept {
        m_inner_iterator_type = other.m_inner_iterator_type;
        m_iterator_holder = other.m_iterator_holder;
        return *this;
    }

    /// @brief Move constructs an iterator.
    iterator(iterator&&) = default;

    /// @brief A move assignment operator of the iterator class.
    iterator& operator=(iterator&&) = default;

    /// @brief Destroys an iterator.
    ~iterator() = default;

    /// @brief An arrow operator of the iterator class.
    /// @return pointer A pointer to the BasicNodeType object internally referenced by the actual iterator object.
    pointer operator->() noexcept {
        if (m_inner_iterator_type == iterator_t::SEQUENCE) {
            return &(*(m_iterator_holder.sequence_iterator));
        }

        // m_inner_iterator_type == iterator_t::MAPPING:
        return &(m_iterator_holder.mapping_iterator->second);
    }

    /// @brief A dereference operator of the iterator class.
    /// @return reference Reference to the Node object internally referenced by the actual iterator object.
    reference operator*() const noexcept {
        if (m_inner_iterator_type == iterator_t::SEQUENCE) {
            return *(m_iterator_holder.sequence_iterator);
        }

        // m_inner_iterator_type == iterator_t::MAPPING:
        return m_iterator_holder.mapping_iterator->second;
    }

    /// @brief A compound assignment operator by sum of the Iterator class.
    /// @param i The difference from this Iterator object with which it moves forward.
    /// @return Iterator& Reference to this Iterator object.
    iterator& operator+=(difference_type i) noexcept {
        switch (m_inner_iterator_type) {
        case iterator_t::SEQUENCE:
            std::advance(m_iterator_holder.sequence_iterator, i);
            break;
        case iterator_t::MAPPING:
            std::advance(m_iterator_holder.mapping_iterator, i);
            break;
        }
        return *this;
    }

    /// @brief A plus operator of the iterator class.
    /// @param i The difference from this iterator object.
    /// @return iterator An iterator object which has been added @a i.
    iterator operator+(difference_type i) const noexcept {
        auto result = *this;
        result += i;
        return result;
    }

    /// @brief An pre-increment operator of the iterator class.
    /// @return iterator& Reference to this iterator object.
    iterator& operator++() noexcept {
        switch (m_inner_iterator_type) {
        case iterator_t::SEQUENCE:
            std::advance(m_iterator_holder.sequence_iterator, 1);
            break;
        case iterator_t::MAPPING:
            std::advance(m_iterator_holder.mapping_iterator, 1);
            break;
        }
        return *this;
    }

    /// @brief A post-increment operator of the iterator class.
    /// @return iterator An iterator object which has been incremented.
    iterator operator++(int) & noexcept {
        auto result = *this;
        ++(*this);
        return result;
    }

    /// @brief A compound assignment operator by difference of the iterator class.
    /// @param i The difference from this iterator object with which it moves backward.
    /// @return iterator& Reference to this iterator object.
    iterator& operator-=(difference_type i) noexcept {
        return operator+=(-i);
    }

    /// @brief A minus operator of the iterator class.
    /// @param i The difference from this iterator object.
    /// @return iterator An iterator object from which has been subtracted @ i.
    iterator operator-(difference_type i) const noexcept {
        auto result = *this;
        result -= i;
        return result;
    }

    /// @brief A pre-decrement operator of the iterator class.
    /// @return iterator& Reference to this iterator object.
    iterator& operator--() noexcept {
        switch (m_inner_iterator_type) {
        case iterator_t::SEQUENCE:
            std::advance(m_iterator_holder.sequence_iterator, -1);
            break;
        case iterator_t::MAPPING:
            std::advance(m_iterator_holder.mapping_iterator, -1);
            break;
        }
        return *this;
    }

    /// @brief A post-decrement operator of the iterator class
    /// @return iterator An iterator object which has been decremented.
    iterator operator--(int) & noexcept {
        auto result = *this;
        --(*this);
        return result;
    }

    /// @brief An equal-to operator of the iterator class.
    /// @param rhs An iterator object to be compared with this iterator object.
    /// @return true  This iterator object is equal to the other.
    /// @return false This iterator object is not equal to the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator==(const Iterator& rhs) const {
        if FK_YAML_UNLIKELY (m_inner_iterator_type != rhs.m_inner_iterator_type) {
            throw fkyaml::exception("Cannot compare iterators of different container types.");
        }

        if (m_inner_iterator_type == iterator_t::SEQUENCE) {
            return (m_iterator_holder.sequence_iterator == rhs.m_iterator_holder.sequence_iterator);
        }

        // m_inner_iterator_type == iterator_t::MAPPING
        return (m_iterator_holder.mapping_iterator == rhs.m_iterator_holder.mapping_iterator);
    }

    /// @brief An not-equal-to operator of the iterator class.
    /// @param rhs An iterator object to be compared with this iterator object.
    /// @return true  This iterator object is not equal to the other.
    /// @return false This iterator object is equal to the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator!=(const Iterator& rhs) const {
        return !operator==(rhs);
    }

    /// @brief A less-than operator of the iterator class.
    /// @param rhs An iterator object to be compared with this iterator object.
    /// @return true  This iterator object is less than the other.
    /// @return false This iterator object is not less than the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator<(const Iterator& rhs) const {
        if FK_YAML_UNLIKELY (m_inner_iterator_type != rhs.m_inner_iterator_type) {
            throw fkyaml::exception("Cannot compare iterators of different container types.");
        }

        if FK_YAML_UNLIKELY (m_inner_iterator_type == iterator_t::MAPPING) {
            throw fkyaml::exception("Cannot compare order of iterators of the mapping container type");
        }

        return (m_iterator_holder.sequence_iterator < rhs.m_iterator_holder.sequence_iterator);
    }

    ///  @brief A less-than-or-equal-to operator of the iterator class.
    ///  @param rhs An iterator object to be compared with this iterator object.
    ///  @return true  This iterator object is either less than or equal to the other.
    ///  @return false This iterator object is neither less than nor equal to the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator<=(const Iterator& rhs) const {
        return !rhs.operator<(*this);
    }

    /// @brief A greater-than operator of the iterator class.
    /// @param rhs An iterator object to be compared with this iterator object.
    /// @return true  This iterator object is greater than the other.
    /// @return false This iterator object is not greater than the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator>(const Iterator& rhs) const {
        return !operator<=(rhs);
    }

    /// @brief A greater-than-or-equal-to operator of the iterator class.
    /// @param rhs An iterator object to be compared with this iterator object.
    /// @return true  This iterator object is either greater than or equal to the other.
    /// @return false This iterator object is neither greater than nor equal to the other.
    template <
        typename Iterator,
        enable_if_t<
            disjunction<std::is_same<Iterator, iterator>, std::is_same<Iterator, other_iterator_type>>::value, int> = 0>
    bool operator>=(const Iterator& rhs) const {
        return !operator<(rhs);
    }

public:
    /// @brief Get the type of the internal iterator implementation.
    /// @return iterator_t The type of the internal iterator implementation.
    iterator_t type() const noexcept {
        return m_inner_iterator_type;
    }

    /// @brief Get the mapping key node of the current iterator.
    /// @return The mapping key node of the current iterator.
    const typename value_type::mapping_type::key_type& key() const {
        if FK_YAML_UNLIKELY (m_inner_iterator_type == iterator_t::SEQUENCE) {
            throw fkyaml::exception("Cannot retrieve key from non-mapping iterators.");
        }

        return m_iterator_holder.mapping_iterator->first;
    }

    /// @brief Get reference to the YAML node of the current iterator.
    /// @return Reference to the YAML node of the current iterator.
    reference value() const noexcept {
        return operator*();
    }

private:
    /// A type of the internally-held iterator.
    iterator_t m_inner_iterator_type {iterator_t::SEQUENCE};
    /// A holder of actual iterators.
    iterator_holder<value_type> m_iterator_holder {};
};

/// @brief Get reference to a mapping key node.
/// @tparam ValueType The iterator value type.
/// @tparam I The element index.
/// @param i An iterator object.
/// @return Reference to a mapping key node.
template <std::size_t I, typename ValueType, enable_if_t<I == 0, int> = 0>
inline auto get(const iterator<ValueType>& i) -> decltype(i.key()) {
    return i.key();
}

/// @brief Get reference to a mapping value node.
/// @tparam ValueType The iterator value type.
/// @tparam I The element index
/// @param i An iterator object.
/// @return Reference to a mapping value node.
template <std::size_t I, typename ValueType, enable_if_t<I == 1, int> = 0>
inline auto get(const iterator<ValueType>& i) -> decltype(i.value()) {
    return i.value();
}

FK_YAML_DETAIL_NAMESPACE_END

namespace std {

#ifdef __clang__
// clang emits warnings against mixed usage of class/struct for tuple_size/tuple_element.
// see also: https://groups.google.com/a/isocpp.org/g/std-discussion/c/QC-AMb5oO1w
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmismatched-tags"
#endif

/// @brief Partial specialization of std::tuple_size for iterator class.
/// @tparam ValueType The iterator value type.
template <typename ValueType>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct tuple_size<::fkyaml::detail::iterator<ValueType>> : integral_constant<size_t, 2> {};

/// @brief Partial specialization of std::tuple_element for iterator class.
/// @tparam ValueType The iterator value type.
/// @tparam I The element index.
template <size_t I, typename ValueType>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct tuple_element<I, ::fkyaml::detail::iterator<ValueType>> {
    using type = decltype(get<I>(std::declval<::fkyaml::detail::iterator<ValueType>>()));
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif

} // namespace std

#endif /* FK_YAML_DETAIL_ITERATOR_HPP */

// #include <fkYAML/detail/map_range_proxy.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_MAP_RANGE_PROXY_HPP
#define FK_YAML_DETAIL_MAP_RANGE_PROXY_HPP

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A helper iterator class which wraps a mapping iterator object.
/// @tparam Iterator The base iterator type.
template <typename Iterator>
class map_iterator_proxy {
public:
    /// @brief The type of the pointed-to elements by base iterators.
    using value_type = Iterator;

    /// @brief The type to represent difference between the pointed-to elements by base iterators.
    using difference_type = std::ptrdiff_t;

    /// @brief The type of the pointed-to element references by base iterators.
    using reference = value_type&;

    /// @brief The type of the pointed-to element pointers by base iterators.
    using pointer = value_type*;

    /// @brief The iterator category.
    using iterator_category = std::forward_iterator_tag;

    /// @brief Constructs a map_iterator_proxy object.
    map_iterator_proxy() = default;

    /// @brief Constructs a map_iterator_proxy object with an Iterator object.
    /// @param i A base iterator object.
    map_iterator_proxy(const Iterator& i) noexcept
        : m_base_iterator(i) {
    }

    /// @brief Copy constructs a map_iterator_proxy object.
    map_iterator_proxy(const map_iterator_proxy&) = default;

    /// @brief Copy assigns a map_iterator_proxy object.
    map_iterator_proxy& operator=(const map_iterator_proxy&) = default;

    /// @brief Move constructs a map_iterator_proxy object.
    map_iterator_proxy(map_iterator_proxy&&) = default;

    /// @brief Move assigns a map_iterator_proxy object.
    map_iterator_proxy& operator=(map_iterator_proxy&&) = default;

    /// @brief Destructs a map_iterator_proxy object.
    ~map_iterator_proxy() = default;

    /// @brief Get reference to the base iterator object.
    /// @return Reference to the base iterator object.
    reference operator*() noexcept {
        return m_base_iterator;
    }

    /// @brief Get pointer to the base iterator object.
    /// @return Pointer to the base iterator object.
    pointer operator->() noexcept {
        return &m_base_iterator;
    }

    /// @brief Pre-increments the base iterator object.
    /// @return Reference to this map_iterator_proxy object.
    map_iterator_proxy& operator++() noexcept {
        ++m_base_iterator;
        return *this;
    }

    /// @brief Post-increments the base iterator object.
    /// @return A map_iterator_proxy object with its base iterator incremented.
    map_iterator_proxy operator++(int) & noexcept {
        auto result = *this;
        ++(*this);
        return result;
    }

    /// @brief Check equality between map_iterator_proxy objects.
    /// @param rhs A map_iterator_proxy object to compare with.
    /// @return true if this map_iterator_proxy object is equal to `rhs`, false otherwise.
    bool operator==(const map_iterator_proxy& rhs) const noexcept {
        return m_base_iterator == rhs.m_base_iterator;
    }

    /// @brief Check inequality between map_iterator_proxy objects.
    /// @param rhs A map_iterator_proxy object to compare with.
    /// @return true if this map_iterator_proxy object is not equal to `rhs`, false otherwise.
    bool operator!=(const map_iterator_proxy& rhs) const noexcept {
        return m_base_iterator != rhs.m_base_iterator;
    }

    /// @brief Get the mapping key node pointed by the base iterator.
    /// @return Reference to the mapping key node.
    typename Iterator::reference key() const {
        return m_base_iterator.key();
    }

    /// @brief Get the mapping value node pointed by the base iterator.
    /// @return Reference to the mapping value node.
    typename Iterator::reference value() const noexcept {
        return m_base_iterator.value();
    }

private:
    /// The base iterator object.
    Iterator m_base_iterator {};
};

/// @brief A helper struct which allows accessing node iterator member functions in range-based for loops.
/// @tparam BasicNodeType A basic_node template instance type.
template <typename BasicNodeType>
class map_range_proxy {
    static_assert(
        is_basic_node<BasicNodeType>::value,
        "map_range_proxy only accepts a basic_node type as its template parameter.");

public:
    /// @brief The type of non-const iterators.
    using iterator = map_iterator_proxy<typename std::conditional<
        std::is_const<BasicNodeType>::value, typename BasicNodeType::const_iterator,
        typename BasicNodeType::iterator>::type>;

    /// @brief The type of const iterators.
    using const_iterator = map_iterator_proxy<typename BasicNodeType::const_iterator>;

    /// @brief Constructs a map_range_proxy object with a BasicNodeType object.
    /// @param map A mapping node object.
    map_range_proxy(BasicNodeType& map) noexcept
        : mp_map(&map) {
    }

    /// @brief Copy constructs a map_range_proxy object.
    map_range_proxy(const map_range_proxy&) = default;

    /// @brief Copy assigns a map_range_proxy object.
    /// @return Reference to this map_range_proxy object.
    map_range_proxy& operator=(const map_range_proxy&) = default;

    /// @brief Move constructs a map_range_proxy object.
    map_range_proxy(map_range_proxy&&) = default;

    /// @brief Move assigns a map_range_proxy object.
    /// @return Reference to this map_range_proxy object.
    map_range_proxy& operator=(map_range_proxy&&) = default;

    /// @brief Destructs a map_range_proxy object.
    ~map_range_proxy() = default;

    /// @brief Get an iterator to the first element.
    /// @return An iterator to the first element.
    iterator begin() noexcept {
        return {mp_map->begin()};
    }

    /// @brief Get a const iterator to the first element.
    /// @return A const iterator to the first element.
    const_iterator begin() const noexcept {
        return {mp_map->cbegin()};
    }

    /// @brief Get an iterator to the past-the-last element.
    /// @return An iterator to the past-the-last element.
    iterator end() noexcept {
        return {mp_map->end()};
    }

    /// @brief Get a const iterator to the past-the-last element.
    /// @return A const iterator to the past-the-last element.
    const_iterator end() const noexcept {
        return {mp_map->cend()};
    }

private:
    /// Pointer to the mapping node object. (non-null)
    BasicNodeType* mp_map {nullptr};
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_MAP_RANGE_PROXY_HPP */

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/detail/node_attrs.hpp>

// #include <fkYAML/detail/node_property.hpp>

// #include <fkYAML/detail/node_ref_storage.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_NODE_REF_STORAGE_HPP
#define FK_YAML_DETAIL_NODE_REF_STORAGE_HPP

#include <initializer_list>
#include <type_traits>
#include <utility>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A temporal storage for basic_node class objects.
/// @note This class makes it easier to handle lvalue basic_node objects in basic_node ctor with std::initializer_list.
/// @tparam BasicNodeType A basic_node template instance type.
template <typename BasicNodeType>
class node_ref_storage {
    static_assert(is_basic_node<BasicNodeType>::value, "node_ref_storage only accepts basic_node<...>");

    using node_type = BasicNodeType;

public:
    /// @brief Construct a new node ref storage object with an rvalue basic_node object.
    /// @param n An rvalue basic_node object.
    explicit node_ref_storage(node_type&& n) noexcept(std::is_nothrow_move_constructible<node_type>::value)
        : m_owned_value(std::move(n)) {
    }

    /// @brief Construct a new node ref storage object with an lvalue basic_node object.
    /// @param n An lvalue basic_node object.
    explicit node_ref_storage(const node_type& n) noexcept
        : m_value_ref(&n) {
    }

    /// @brief Construct a new node ref storage object with a std::initializer_list object.
    /// @param init A std::initializer_list object.
    node_ref_storage(std::initializer_list<node_ref_storage> init)
        : m_owned_value(init) {
    }

    /// @brief Construct a new node ref storage object with variadic template arguments
    /// @tparam Args Types of arguments to construct a basic_node object.
    /// @param args Arguments to construct a basic_node object.
    template <typename... Args, enable_if_t<std::is_constructible<node_type, Args...>::value, int> = 0>
    node_ref_storage(Args&&... args)
        : m_owned_value(std::forward<Args>(args)...) {
    }

    // allow only move construct/assignment
    node_ref_storage(const node_ref_storage&) = delete;
    node_ref_storage(node_ref_storage&&) = default;
    node_ref_storage& operator=(const node_ref_storage&) = delete;
    node_ref_storage& operator=(node_ref_storage&&) = default;

    ~node_ref_storage() = default;

public:
    /// @brief An arrow operator for node_ref_storage objects.
    /// @return const node_type* A constant pointer to a basic_node object.
    const node_type* operator->() const noexcept {
        return m_value_ref ? m_value_ref : &m_owned_value;
    }

    /// @brief Releases a basic_node object internally held.
    /// @return node_type A basic_node object internally held.
    node_type release() const noexcept {
        return m_value_ref ? *m_value_ref : std::move(m_owned_value);
    }

private:
    /// A storage for a basic_node object given with rvalue reference.
    mutable node_type m_owned_value = nullptr;
    /// A pointer to a basic_node object given with lvalue reference.
    const node_type* m_value_ref = nullptr;
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_NODE_REF_STORAGE_HPP */

// #include <fkYAML/detail/output/serializer.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_OUTPUT_SERIALIZER_HPP
#define FK_YAML_DETAIL_OUTPUT_SERIALIZER_HPP

#include <cmath>
#include <sstream>
#include <string>
#include <vector>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/conversions/to_string.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_CONVERSIONS_TO_STRING_HPP
#define FK_YAML_DETAIL_CONVERSIONS_TO_STRING_HPP

#include <cmath>
#include <limits>
#include <string>
#include <sstream>
#include <type_traits>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Converts a ValueType object to a string YAML token.
/// @tparam ValueType A source value type.
/// @tparam CharType The type of characters for the conversion result.
/// @param s A resulting output string.
/// @param v A source value.
template <typename ValueType, typename CharType>
inline void to_string(ValueType v, std::basic_string<CharType>& s) noexcept;

/// @brief Specialization of to_string() for null values.
/// @param s A resulting string YAML token.
/// @param (unused) nullptr
template <>
inline void to_string(std::nullptr_t /*unused*/, std::string& s) noexcept {
    s = "null";
}

/// @brief Specialization of to_string() for booleans.
/// @param s A resulting string YAML token.
/// @param v A boolean source value.
template <>
inline void to_string(bool v, std::string& s) noexcept {
    s = v ? "true" : "false";
}

/// @brief Specialization of to_string() for integers.
/// @tparam IntegerType An integer type.
/// @param s A resulting string YAML token.
/// @param i An integer source value.
template <typename IntegerType>
inline enable_if_t<is_non_bool_integral<IntegerType>::value> to_string(IntegerType v, std::string& s) noexcept {
    s = std::to_string(v);
}

/// @brief Specialization of to_string() for floating point numbers.
/// @tparam FloatType A floating point number type.
/// @param s A resulting string YAML token.
/// @param f A floating point number source value.
template <typename FloatType>
inline enable_if_t<std::is_floating_point<FloatType>::value> to_string(FloatType v, std::string& s) noexcept {
    if (std::isnan(v)) {
        s = ".nan";
        return;
    }

    if (std::isinf(v)) {
        if (v == std::numeric_limits<FloatType>::infinity()) {
            s = ".inf";
        }
        else {
            s = "-.inf";
        }
        return;
    }

    std::ostringstream oss;
    oss << v;
    s = oss.str();

    // If `v` is actually an integer and no scientific notation is used for serialization, ".0" must be appended.
    // The result would cause a roundtrip issue otherwise. https://github.com/fktn-k/fkYAML/issues/405
    const std::size_t pos = s.find_first_of(".e");
    if (pos == std::string::npos) {
        s += ".0";
    }
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_CONVERSIONS_TO_STRING_HPP */

// #include <fkYAML/detail/encodings/yaml_escaper.hpp>

// #include <fkYAML/detail/input/scalar_scanner.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/exception.hpp>

// #include <fkYAML/node_type.hpp>

// #include <fkYAML/yaml_version_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief A basic implementation of serialization feature for YAML nodes.
/// @tparam BasicNodeType A BasicNode template class instantiation.
template <typename BasicNodeType>
class basic_serializer {
    static_assert(detail::is_basic_node<BasicNodeType>::value, "basic_serializer only accepts basic_node<...>");

public:
    /// @brief Construct a new basic_serializer object.
    basic_serializer() = default;

    /// @brief Serialize the given Node value.
    /// @param node A Node object to be serialized.
    /// @return std::string A serialization result of the given Node value.
    std::string serialize(const BasicNodeType& node) {
        std::string str {};
        serialize_document(node, str);
        return str;
    } // LCOV_EXCL_LINE

    std::string serialize_docs(const std::vector<BasicNodeType>& docs) {
        std::string str {};

        const auto size = static_cast<uint32_t>(docs.size());
        for (uint32_t i = 0; i < size; i++) {
            serialize_document(docs[i], str);
            if (i + 1 < size) {
                // Append the end-of-document marker for the next document.
                str += "...\n";
            }
        }

        return str;
    } // LCOV_EXCL_LINE

private:
    void serialize_document(const BasicNodeType& node, std::string& str) {
        const bool dirs_serialized = serialize_directives(node, str);

        // the root node cannot be an alias node.
        const bool root_has_props = node.is_anchor() || node.has_tag_name();

        if (root_has_props) {
            if (dirs_serialized) {
                str.back() = ' '; // replace the last LF with a white space
            }
            bool is_anchor_appended = try_append_anchor(node, false, str);
            try_append_tag(node, is_anchor_appended, str);
            str += "\n";
        }
        serialize_node(node, 0, str);
    }

    /// @brief Serialize the directives if any is applied to the node.
    /// @param node The target node.
    /// @param str A string to hold serialization result.
    /// @return bool true if any directive is serialized, false otherwise.
    bool serialize_directives(const BasicNodeType& node, std::string& str) {
        const auto& p_meta = node.mp_meta;
        bool needs_directive_end = false;

        if (p_meta->is_version_specified) {
            str += "%YAML ";
            switch (p_meta->version) {
            case yaml_version_type::VERSION_1_1:
                str += "1.1\n";
                break;
            case yaml_version_type::VERSION_1_2:
                str += "1.2\n";
                break;
            }
            needs_directive_end = true;
        }

        if (!p_meta->primary_handle_prefix.empty()) {
            str += "%TAG ! ";
            str += p_meta->primary_handle_prefix;
            str += "\n";
            needs_directive_end = true;
        }

        if (!p_meta->secondary_handle_prefix.empty()) {
            str += "%TAG !! ";
            str += p_meta->secondary_handle_prefix;
            str += "\n";
            needs_directive_end = true;
        }

        if (!p_meta->named_handle_map.empty()) {
            for (const auto& itr : p_meta->named_handle_map) {
                str += "%TAG ";
                str += itr.first;
                str += " ";
                str += itr.second;
                str += "\n";
            }
            needs_directive_end = true;
        }

        if (needs_directive_end) {
            str += "---\n";
        }

        return needs_directive_end;
    }

    /// @brief Recursively serialize each Node object.
    /// @param node A Node object to be serialized.
    /// @param cur_indent The current indent width
    /// @param str A string to hold serialization result.
    void serialize_node(const BasicNodeType& node, const uint32_t cur_indent, std::string& str) {
        switch (node.get_type()) {
        case node_type::SEQUENCE:
            if (node.size() == 0) {
                str += "[]\n";
                return;
            }
            for (const auto& seq_item : node) {
                insert_indentation(cur_indent, str);
                str += "-";

                const bool is_appended = try_append_alias(seq_item, true, str);
                if (is_appended) {
                    str += "\n";
                    continue;
                }

                try_append_anchor(seq_item, true, str);
                try_append_tag(seq_item, true, str);

                const bool is_scalar = seq_item.is_scalar();
                if (is_scalar) {
                    str += " ";
                    serialize_node(seq_item, cur_indent, str);
                    str += "\n";
                    continue;
                }

                const bool is_empty = seq_item.empty();
                if (!is_empty) {
                    str += "\n";
                    serialize_node(seq_item, cur_indent + 2, str);
                    continue;
                }

                // an empty sequence or mapping
                if (seq_item.is_sequence()) {
                    str += " []\n";
                }
                else /*seq_item.is_mapping()*/ {
                    str += " {}\n";
                }
            }
            break;
        case node_type::MAPPING:
            if (node.size() == 0) {
                str += "{}\n";
                return;
            }
            for (auto itr : node.map_items()) {
                insert_indentation(cur_indent, str);

                // serialize a mapping key node.
                const auto& key_node = itr.key();

                bool is_appended = try_append_alias(key_node, false, str);
                if (is_appended) {
                    // The trailing white space is necessary since anchor names can contain a colon (:) at its end.
                    str += " ";
                }
                else {
                    const bool is_anchor_appended = try_append_anchor(key_node, false, str);
                    const bool is_tag_appended = try_append_tag(key_node, is_anchor_appended, str);
                    if (is_anchor_appended || is_tag_appended) {
                        str += " ";
                    }

                    const bool is_container = !key_node.is_scalar();
                    if (is_container) {
                        str += "? ";
                    }
                    const auto indent = static_cast<uint32_t>(get_cur_indent(str));
                    serialize_node(key_node, indent, str);
                    if (is_container) {
                        // a newline code is already inserted in the above serialize_node() call.
                        insert_indentation(indent - 2, str);
                    }
                }

                str += ":";

                // serialize a mapping value node.
                const auto& value_node = itr.value();

                is_appended = try_append_alias(value_node, true, str);
                if (is_appended) {
                    str += "\n";
                    continue;
                }

                try_append_anchor(value_node, true, str);
                try_append_tag(value_node, true, str);

                const bool is_scalar = itr->is_scalar();
                if (is_scalar) {
                    str += " ";
                    serialize_node(value_node, cur_indent, str);
                    str += "\n";
                    continue;
                }

                const bool is_empty = itr->empty();
                if (is_empty) {
                    str += " ";
                }
                else {
                    str += "\n";
                }
                serialize_node(value_node, cur_indent + 2, str);
            }
            break;
        case node_type::NULL_OBJECT:
            to_string(nullptr, m_tmp_str_buff);
            str += m_tmp_str_buff;
            break;
        case node_type::BOOLEAN:
            to_string(node.template get_value<typename BasicNodeType::boolean_type>(), m_tmp_str_buff);
            str += m_tmp_str_buff;
            break;
        case node_type::INTEGER:
            to_string(node.template get_value<typename BasicNodeType::integer_type>(), m_tmp_str_buff);
            str += m_tmp_str_buff;
            break;
        case node_type::FLOAT:
            to_string(node.template get_value<typename BasicNodeType::float_number_type>(), m_tmp_str_buff);
            str += m_tmp_str_buff;
            break;
        case node_type::STRING: {
            bool is_escaped = false;
            auto str_val = get_string_node_value(node, is_escaped);

            if (is_escaped) {
                // There's no other token type with escapes than strings.
                // Also, escapes must be in double-quoted strings.
                str += '\"';
                str += str_val;
                str += '\"';
                break;
            }

            // The next line is intentionally excluded from the LCOV coverage target since the next line is somehow
            // misrecognized as it has a binary branch. Possibly begin() or end() has some conditional branch(es)
            // internally. Confirmed with LCOV 1.14 on Ubuntu22.04.
            const node_type type_if_plain =
                scalar_scanner::scan(str_val.c_str(), str_val.c_str() + str_val.size()); // LCOV_EXCL_LINE

            if (type_if_plain != node_type::STRING) {
                // Surround a string value with double quotes to keep semantic equality.
                // Without them, serialized values will become non-string. (e.g., "1" -> 1)
                str += '\"';
                str += str_val;
                str += '\"';
            }
            else {
                str += str_val;
            }
            break;
        }
        }
    }

    /// @brief Get the current indentation width.
    /// @param s The target string object.
    /// @return The current indentation width.
    std::size_t get_cur_indent(const std::string& s) const noexcept {
        const bool is_empty = s.empty();
        if (is_empty) {
            return 0;
        }

        const std::size_t last_lf_pos = s.rfind('\n');
        return (last_lf_pos != std::string::npos) ? s.size() - last_lf_pos - 1 : s.size();
    }

    /// @brief Insert indentation to the serialization result.
    /// @param indent The indent width to be inserted.
    /// @param str A string to hold serialization result.
    void insert_indentation(const uint32_t indent, std::string& str) const noexcept {
        if (indent == 0) {
            return;
        }

        str.append(indent - get_cur_indent(str), ' ');
    }

    /// @brief Append an anchor property if it's available. Do nothing otherwise.
    /// @param node The target node which is possibly an anchor node.
    /// @param prepends_space Whether to prepend a space before an anchor property.
    /// @param str A string to hold serialization result.
    /// @return true if an anchor property has been appended, false otherwise.
    bool try_append_anchor(const BasicNodeType& node, bool prepends_space, std::string& str) const {
        if (node.is_anchor()) {
            if (prepends_space) {
                str += " ";
            }
            str += "&" + node.get_anchor_name();
            return true;
        }
        return false;
    }

    /// @brief Append an alias property if it's available. Do nothing otherwise.
    /// @param node The target node which is possibly an alias node.
    /// @param prepends_space Whether to prepend a space before an alias property.
    /// @param str A string to hold serialization result.
    /// @return true if an alias property has been appended, false otherwise.
    bool try_append_alias(const BasicNodeType& node, bool prepends_space, std::string& str) const {
        if (node.is_alias()) {
            if (prepends_space) {
                str += " ";
            }
            str += "*" + node.get_anchor_name();
            return true;
        }
        return false;
    }

    /// @brief Append a tag name if it's available. Do nothing otherwise.
    /// @param[in] node The target node which possibly has a tag name.
    /// @param[out] str A string to hold serialization result.
    /// @return true if a tag name has been appended, false otherwise.
    bool try_append_tag(const BasicNodeType& node, bool prepends_space, std::string& str) const {
        if (node.has_tag_name()) {
            if (prepends_space) {
                str += " ";
            }
            str += node.get_tag_name();
            return true;
        }
        return false;
    }

    /// @brief Get a string value from the given node and, if necessary, escape its contents.
    /// @param[in] node The target string YAML node.
    /// @param[out] is_escaped Whether the contents of an output string has been escaped.
    /// @return The (escaped) string node value.
    typename BasicNodeType::string_type get_string_node_value(const BasicNodeType& node, bool& is_escaped) {
        FK_YAML_ASSERT(node.is_string());

        const auto& s = node.as_str();
        return yaml_escaper::escape(s.c_str(), s.c_str() + s.size(), is_escaped);
    } // LCOV_EXCL_LINE

private:
    /// A temporal buffer for conversion from a scalar to a string.
    std::string m_tmp_str_buff;
};

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_OUTPUT_SERIALIZER_HPP */

// #include <fkYAML/detail/reverse_iterator.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_REVERSE_ITERATOR_HPP
#define FK_YAML_DETAIL_REVERSE_ITERATOR_HPP

#include <iterator>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief An iterator adapter class that reverses the direction of a given node iterator.
/// @tparam Iterator The base iterator type.
template <typename Iterator>
class reverse_iterator {
    static_assert(
        is_basic_node<typename Iterator::value_type>::value,
        "reverse_iterator only accepts a basic_node type as the underlying iterator's value type");

public:
    /// @brief The base iterator type.
    using iterator_type = Iterator;

    /// @brief The base iterator category.
    using iterator_category = typename Iterator::iterator_category;

    /// @brief The type of the pointed-to elements by base iterators.
    using value_type = typename Iterator::value_type;

    /// @brief The type to represent differences between the pointed-to elements by the base iterators.
    using difference_type = typename Iterator::difference_type;

    /// @brief The type of the pointed-to element pointers by base iterators.
    using pointer = typename Iterator::pointer;

    /// @brief The type of the pointed-to element references by base iterators.
    using reference = typename Iterator::reference;

    /// @brief Constructs a reverse_iterator object.
    reverse_iterator() = default;

    /// @brief Copy constructs a reverse_iterator object.
    reverse_iterator(const reverse_iterator&) = default;

    /// @brief Copy assignments a reverse_iterator object.
    reverse_iterator& operator=(const reverse_iterator&) = default;

    /// @brief Move constructs a reverse_iterator object.
    reverse_iterator(reverse_iterator&&) = default;

    /// @brief Move assignments a reverse_iterator object.
    reverse_iterator& operator=(reverse_iterator&&) = default;

    /// @brief Constructs a reverse_iterator object with an underlying iterator object.
    /// @param i A base iterator object.
    reverse_iterator(const Iterator& i) noexcept
        : m_current(i) {
    }

    /// @brief Copy constructs a reverse_iterator object with a compatible reverse_iterator object.
    /// @tparam U A compatible iterator type with Iterator.
    /// @param other A compatible reverse_iterator object.
    template <typename U, enable_if_t<negation<std::is_same<U, Iterator>>::value, int> = 0>
    reverse_iterator(const reverse_iterator<U>& other) noexcept
        : m_current(other.base()) {
    }

    /// @brief Copy assigns a reverse_iterator object with a compatible reverse_iterator object.
    /// @tparam U A compatible iterator type with Iterator.
    /// @param other A compatible reverse_iterator object.
    /// @return Reference to this reverse_iterator object.
    template <typename U, enable_if_t<negation<std::is_same<U, Iterator>>::value, int> = 0>
    reverse_iterator& operator=(const reverse_iterator<U>& other) noexcept {
        m_current = other.base();
        return *this;
    }

    /// @brief Destructs a reverse_iterator object.
    ~reverse_iterator() = default;

    /// @brief Accesses the underlying iterator object.
    /// @return The underlying iterator object.
    Iterator base() const noexcept {
        return m_current;
    }

    /// @brief Get reference to the pointed-to element.
    /// @return Reference to the pointed-to element.
    reference operator*() const noexcept {
        Iterator tmp = m_current;
        return *--tmp;
    }

    /// @brief Get pointer to the pointed-to element.
    /// @return Pointer to the pointed-to element.
    pointer operator->() const noexcept {
        return &(operator*());
    }

    /// @brief Pre-increments the underlying iterator object.
    /// @return Reference to this reverse_iterator object with its underlying iterator incremented.
    reverse_iterator& operator++() noexcept {
        --m_current;
        return *this;
    }

    /// @brief Post-increments the underlying iterator object.
    /// @return A reverse_iterator object with the underlying iterator as-is.
    reverse_iterator operator++(int) & noexcept {
        auto result = *this;
        --m_current;
        return result;
    }

    /// @brief Pre-decrements the underlying iterator object.
    /// @return Reference to this reverse_iterator with its underlying iterator decremented.
    reverse_iterator& operator--() noexcept {
        ++m_current;
        return *this;
    }

    /// @brief Post-decrements the underlying iterator object.
    /// @return A reverse_iterator object with the underlying iterator as-is.
    reverse_iterator operator--(int) & noexcept {
        auto result = *this;
        ++m_current;
        return result;
    }

    /// @brief Advances the underlying iterator object by `n`.
    /// @param n The distance by which the underlying iterator is advanced.
    /// @return A reverse_iterator object with the underlying iterator advanced by `n`.
    reverse_iterator operator+(difference_type n) const noexcept {
        return reverse_iterator(m_current - n);
    }

    /// @brief Advances the underlying iterator object by `n`.
    /// @param n The distance by which the underlying iterator is advanced.
    /// @return Reference to this reverse_iterator object with the underlying iterator advanced by `n`.
    reverse_iterator& operator+=(difference_type n) noexcept {
        m_current -= n;
        return *this;
    }

    /// @brief Decrements the underlying iterator object by `n`.
    /// @param n The distance by which the underlying iterator is decremented.
    /// @return A reverse_iterator object with the underlying iterator decremented by `n`.
    reverse_iterator operator-(difference_type n) const noexcept {
        return reverse_iterator(m_current + n);
    }

    /// @brief Decrements the underlying iterator object by `n`.
    /// @param n The distance by which the underlying iterator is decremented.
    /// @return Reference to this reverse_iterator object with the underlying iterator decremented by `n`.
    reverse_iterator& operator-=(difference_type n) noexcept {
        m_current += n;
        return *this;
    }

    /// @brief Get the mapping key node of the underlying iterator.
    /// @return The mapping key node of the underlying iterator.
    auto key() const -> decltype(std::declval<Iterator>().key()) {
        Iterator itr = --(base());
        return itr.key();
    }

    /// @brief Get reference to the underlying iterator's value.
    /// @return Reference to the underlying iterator's value.
    reference value() noexcept {
        Iterator itr = --(base());
        return *itr;
    }

private:
    ///
    Iterator m_current;
};

/// @brief Check equality between reverse_iterator objects.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if the two reverse_iterator objects are equal, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator==(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() == rhs.base();
}

/// @brief Check inequality between reverse_iterator objects.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if the two reverse_iterator objects are not equal, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator!=(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() != rhs.base();
}

/// @brief Check if `lhs` is less than `rhs`.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if `lhs` is less than `rhs`, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator<(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() > rhs.base();
}

/// @brief Check if `lhs` is less than or equal to `rhs`.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if `lhs` is less than or equal to `rhs`, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator<=(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() >= rhs.base();
}

/// @brief Check if `lhs` is greater than `rhs`.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if `lhs` is greater than `rhs`, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator>(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() < rhs.base();
}

/// @brief Check if `lhs` is greater than or equal to `rhs`.
/// @tparam IteratorL Base iterator type for `lhs`.
/// @tparam IteratorR Base iterator type for `rhs`.
/// @param lhs A reverse_iterator object.
/// @param rhs A reverse_iterator object.
/// @return true if `lhs` is greater than or equal to `rhs`, false otherwise.
template <typename IteratorL, typename IteratorR>
inline bool operator>=(const reverse_iterator<IteratorL>& lhs, const reverse_iterator<IteratorR>& rhs) {
    return lhs.base() <= rhs.base();
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_REVERSE_ITERATOR_HPP */

// #include <fkYAML/detail/types/node_t.hpp>

// #include <fkYAML/detail/types/yaml_version_t.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_TYPES_YAML_VERSION_T_HPP
#define FK_YAML_DETAIL_TYPES_YAML_VERSION_T_HPP

#include <cstdint>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/yaml_version_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

/// @brief Definition of YAML version types.
enum class yaml_version_t : std::uint8_t {
    VER_1_1, //!< YAML version 1.1
    VER_1_2, //!< YAML version 1.2
};

inline yaml_version_t convert_from_yaml_version_type(yaml_version_type t) noexcept {
    switch (t) {
    case yaml_version_type::VERSION_1_1:
        return yaml_version_t::VER_1_1;
    case yaml_version_type::VERSION_1_2:
    default:
        return yaml_version_t::VER_1_2;
    }
}

inline yaml_version_type convert_to_yaml_version_type(yaml_version_t t) noexcept {
    switch (t) {
    case yaml_version_t::VER_1_1:
        return yaml_version_type::VERSION_1_1;
    case yaml_version_t::VER_1_2:
    default:
        return yaml_version_type::VERSION_1_2;
    }
}

FK_YAML_DETAIL_NAMESPACE_END

#endif /* FK_YAML_DETAIL_TYPES_YAML_VERSION_T_HPP */

// #include <fkYAML/exception.hpp>

// #include <fkYAML/node_type.hpp>

// #include <fkYAML/node_value_converter.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_NODE_VALUE_CONVERTER_HPP
#define FK_YAML_NODE_VALUE_CONVERTER_HPP

#include <utility>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/conversions/from_node.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_CONVERSIONS_FROM_NODE_HPP
#define FK_YAML_DETAIL_CONVERSIONS_FROM_NODE_HPP

#include <array>
#include <cmath>
#include <forward_list>
#include <limits>
#include <utility>
#include <valarray>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/detail/types/node_t.hpp>

// #include <fkYAML/exception.hpp>


#ifdef FK_YAML_HAS_CXX_17
#include <optional>
#endif

FK_YAML_DETAIL_NAMESPACE_BEGIN

///////////////////
//   from_node   //
///////////////////

// utility type traits and functors

/// @brief Utility traits type alias to detect constructible associative container types from a mapping node, e.g.,
/// std::map or std::unordered_map.
/// @tparam T A target type for detection.
template <typename T>
using is_constructible_mapping_type =
    conjunction<detect::has_key_type<T>, detect::has_mapped_type<T>, detect::has_value_type<T>>;

/// @brief Utility traits type alias to detect constructible container types from a sequence node, e.g., std::vector or
/// std::list.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A target type for detection.
template <typename BasicNodeType, typename T>
using is_constructible_sequence_type = conjunction<
    negation<is_basic_node<T>>, detect::has_iterator<T>, detect::is_iterator_traits<typename T::iterator>,
    detect::has_begin_end<T>, negation<std::is_same<T, typename BasicNodeType::mapping_type>>,
    negation<is_constructible_mapping_type<T>>>;

/// @brief Utility traits type alias to detect a sequence container adapter type, e.g., std::stack or std::queue.
/// @tparam T A target type for detection.
template <typename T>
using is_sequence_container_adapter = conjunction<
    negation<is_basic_node<T>>, detect::has_container_type<T>, detect::has_value_type<T>,
    negation<detect::has_key_type<T>>>;

/// @brief Helper struct for reserve() member function call switch for types which do not have reserve function.
/// @tparam ContainerType A container type.
template <typename ContainerType, typename = void>
struct call_reserve_if_available {
    /// @brief Do nothing since ContainerType does not have reserve function.
    static void call(ContainerType& /*unused*/, typename ContainerType::size_type /*unused*/) {
    }
};

/// @brief Helper struct for reserve() member function call switch for types which have reserve function.
/// @tparam ContainerType A container type.
template <typename ContainerType>
struct call_reserve_if_available<ContainerType, enable_if_t<detect::has_reserve<ContainerType>::value>> {
    /// @brief Call reserve function on the ContainerType object with a given size.
    /// @param c A container object.
    /// @param n A size to reserve.
    static void call(ContainerType& c, typename ContainerType::size_type n) {
        c.reserve(n);
    }
};

// from_node() implementations

/// @brief from_node function for C-style 1D arrays whose element type must be a basic_node template instance type or a
/// compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of C-style 1D array.
/// @tparam N Size of the array.
/// @param n A basic_node object.
/// @param array An array object.
template <typename BasicNodeType, typename T, std::size_t N>
inline auto from_node(const BasicNodeType& n, T (&array)[N])
    -> decltype(n.get_value_inplace(std::declval<T&>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
    for (std::size_t i = 0; i < N; i++) {
        n.at(i).get_value_inplace(array[i]);
    }
}

/// @brief from_node function for C-style 2D arrays whose element type must be a basic_node template instance type or a
/// compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of C-style 2D array.
/// @tparam N0 Size of the outer dimension.
/// @tparam N1 Size of the inner dimension.
/// @param n A basic_node object.
/// @param array An array object.
template <typename BasicNodeType, typename T, std::size_t N0, std::size_t N1>
inline auto from_node(const BasicNodeType& n, T (&array)[N0][N1])
    -> decltype(n.get_value_inplace(std::declval<T&>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
    for (std::size_t i0 = 0; i0 < N0; i0++) {
        for (std::size_t i1 = 0; i1 < N1; i1++) {
            n.at(i0).at(i1).get_value_inplace(array[i0][i1]);
        }
    }
}

/// @brief from_node function for C-style 2D arrays whose element type must be a basic_node template instance type or a
/// compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of C-style 2D array.
/// @tparam N0 Size of the outermost dimension.
/// @tparam N1 Size of the middle dimension.
/// @tparam N2 Size of the innermost dimension.
/// @param n A basic_node object.
/// @param array An array object.
template <typename BasicNodeType, typename T, std::size_t N0, std::size_t N1, std::size_t N2>
inline auto from_node(const BasicNodeType& n, T (&array)[N0][N1][N2])
    -> decltype(n.get_value_inplace(std::declval<T&>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
    for (std::size_t i0 = 0; i0 < N0; i0++) {
        for (std::size_t i1 = 0; i1 < N1; i1++) {
            for (std::size_t i2 = 0; i2 < N2; i2++) {
                n.at(i0).at(i1).at(i2).get_value_inplace(array[i0][i1][i2]);
            }
        }
    }
}

/// @brief from_node function for std::array objects whose element type must be a basic_node template instance type or a
/// compatible type. This function is necessary since insert function is not implemented for std::array.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of std::array.
/// @tparam N Size of std::array.
/// @param n A basic_node object.
/// @param arr A std::array object.
template <typename BasicNodeType, typename T, std::size_t N>
inline auto from_node(const BasicNodeType& n, std::array<T, N>& arr)
    -> decltype(n.get_value_inplace(std::declval<T&>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    for (std::size_t i = 0; i < N; i++) {
        // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
        n.at(i).get_value_inplace(arr.at(i));
    }
}

/// @brief from_node function for std::valarray objects whose element type must be a basic_node template instance type
/// or a compatible type. This function is necessary since insert function is not implemented for std::valarray.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of std::valarray.
/// @param n A basic_node object.
/// @param va A std::valarray object.
template <typename BasicNodeType, typename T>
inline auto from_node(const BasicNodeType& n, std::valarray<T>& va)
    -> decltype(n.get_value_inplace(std::declval<T&>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    std::size_t count = n.size();
    va.resize(count);
    for (std::size_t i = 0; i < count; i++) {
        // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
        n.at(i).get_value_inplace(va[i]);
    }
}

/// @brief from_node function for std::forward_list objects whose element type must be a basic_node template instance
/// type or a compatible type. This function is necessary since insert function is not implemented for
/// std::forward_list.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T Element type of std::forward_list.
/// @tparam Alloc Allocator type of std::forward_list.
/// @param n A basic_node object.
/// @param fl A std::forward_list object.
template <typename BasicNodeType, typename T, typename Alloc>
inline auto from_node(const BasicNodeType& n, std::forward_list<T, Alloc>& fl)
    -> decltype(n.template get_value<T>(), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value is not sequence type.", n.get_type());
    }

    fl.clear();

    // std::forward_list does not have insert function.
    auto insert_pos_itr = fl.before_begin();
    for (const auto& elem : n) {
        insert_pos_itr = fl.emplace_after(insert_pos_itr, elem.template get_value<T>());
    }
}

/// @brief from_node function for container objects of only keys or values, e.g., std::vector or std::set, whose element
/// type must be a basic_node template instance type or a compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatSeqType A container type.
/// @param n A basic_node object.
/// @param s A container object.
template <
    typename BasicNodeType, typename CompatSeqType,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>, is_constructible_sequence_type<BasicNodeType, CompatSeqType>,
            negation<std::is_constructible<typename BasicNodeType::string_type, CompatSeqType>>>::value,
        int> = 0>
inline auto from_node(const BasicNodeType& n, CompatSeqType& s)
    -> decltype(n.template get_value<typename CompatSeqType::value_type>(), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value is not sequence type.", n.get_type());
    }

    s.clear();

    // call reserve function first if it's available (like std::vector).
    call_reserve_if_available<CompatSeqType>::call(s, n.size());

    // transform a sequence node into a destination type object by calling insert function.
    using std::end;
    std::transform(n.begin(), n.end(), std::inserter(s, end(s)), [](const BasicNodeType& elem) {
        return elem.template get_value<typename CompatSeqType::value_type>();
    });
}

/// @brief from_node function for sequence container adapter objects, e.g., std::stack or std::queue, whose element type
/// must be either a basic_node template instance type or a compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam SeqContainerAdapter A sequence container adapter type.
/// @param n A node object.
/// @param ca A sequence container adapter object.
template <
    typename BasicNodeType, typename SeqContainerAdapter,
    enable_if_t<
        conjunction<is_basic_node<BasicNodeType>, is_sequence_container_adapter<SeqContainerAdapter>>::value, int> = 0>
inline auto from_node(const BasicNodeType& n, SeqContainerAdapter& ca)
    -> decltype(n.template get_value<typename SeqContainerAdapter::value_type>(), ca.push(std::declval<typename SeqContainerAdapter::value_type>()), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value is not sequence type.", n.get_type());
    }

    // clear existing elements manually since clear function is not implemented for container adapter classes.
    while (!ca.empty()) {
        ca.pop();
    }

    for (const auto& elem : n) {
        // container adapter classes commonly have push function.
        // emplace function cannot be used in case SeqContainerAdapter::container_type is std::vector<bool> in C++11.
        ca.push(elem.template get_value<typename SeqContainerAdapter::value_type>());
    }
}

/// @brief from_node function for mappings whose key and value are of both compatible types.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatibleKeyType Mapping key type compatible with BasicNodeType.
/// @tparam CompatibleValueType Mapping value type compatible with BasicNodeType.
/// @tparam Compare Comparator type for mapping keys.
/// @tparam Allocator Allocator type for destination mapping object.
/// @param n A node object.
/// @param m Mapping container object to store converted key/value objects.
template <typename BasicNodeType, typename CompatMapType, enable_if_t<is_constructible_mapping_type<CompatMapType>::value, int> = 0>
inline auto from_node(const BasicNodeType& n, CompatMapType& m)
    -> decltype(
        std::declval<const BasicNodeType&>().template get_value<typename CompatMapType::key_type>(),
        std::declval<const BasicNodeType&>().template get_value<typename CompatMapType::mapped_type>(),
        m.emplace(std::declval<typename CompatMapType::key_type>(), std::declval<typename CompatMapType::mapped_type>()),
        void()) {
    if FK_YAML_UNLIKELY (!n.is_mapping()) {
        throw type_error("The target node value type is not mapping type.", n.get_type());
    }

    m.clear();
    call_reserve_if_available<CompatMapType>::call(m, n.size());

    for (const auto& pair : n.as_map()) {
        m.emplace(
            pair.first.template get_value<typename CompatMapType::key_type>(),
            pair.second.template get_value<typename CompatMapType::mapped_type>());
    }
}

/// @brief from_node function for nullptr.
/// @tparam BasicNodeType A basic_node template instance type.
/// @param n A node object.
/// @param null Storage for a null value.
template <typename BasicNodeType, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void from_node(const BasicNodeType& n, std::nullptr_t& null) {
    // to ensure the target node value type is null.
    if FK_YAML_UNLIKELY (!n.is_null()) {
        throw type_error("The target node value type is not null type.", n.get_type());
    }
    null = nullptr;
}

/// @brief from_node function for booleans.
/// @tparam BasicNodeType A basic_node template instance type.
/// @param n A node object.
/// @param b Storage for a boolean value.
template <typename BasicNodeType, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void from_node(const BasicNodeType& n, bool& b) {
    switch (n.get_type()) {
    case node_type::NULL_OBJECT:
        // nullptr is converted to false just as C++ implicitly does.
        b = false;
        break;
    case node_type::BOOLEAN:
        b = static_cast<bool>(n.as_bool());
        break;
    case node_type::INTEGER:
        // true: non-zero, false: zero
        b = (n.as_int() != 0);
        break;
    case node_type::FLOAT:
        // true: non-zero, false: zero
        using float_type = typename BasicNodeType::float_number_type;
        b = (n.as_float() != static_cast<float_type>(0.));
        break;
    case node_type::SEQUENCE:
    case node_type::MAPPING:
    case node_type::STRING:
    default:
        throw type_error("The target node value type is not compatible with boolean type.", n.get_type());
    }
}

/// @brief Helper struct for node-to-int conversion.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam IntType Target integer value type (same as BasicNodeType::integer_type)
template <
    typename BasicNodeType, typename IntType, bool = std::is_same<typename BasicNodeType::integer_type, IntType>::value>
struct from_node_int_helper {
    /// @brief Convert node's integer value to the target integer type.
    /// @param n A node object.
    /// @return An integer value converted from the node's integer value.
    static IntType convert(const BasicNodeType& n) {
        return n.as_int();
    }
};

/// @brief Helper struct for node-to-int conversion if IntType is not the node's integer value type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam IntType Target integer value type (different from BasicNodeType::integer_type)
template <typename BasicNodeType, typename IntType>
struct from_node_int_helper<BasicNodeType, IntType, false> {
    /// @brief Convert node's integer value to non-uint64_t integer types.
    /// @param n A node object.
    /// @return An integer value converted from the node's integer value.
    static IntType convert(const BasicNodeType& n) {
        using node_int_type = typename BasicNodeType::integer_type;
        const node_int_type tmp_int = n.as_int();

        // under/overflow check.
        if (std::is_same<IntType, uint64_t>::value) {
            if FK_YAML_UNLIKELY (tmp_int < 0) {
                throw exception("Integer value underflow detected.");
            }
        }
        else {
            if FK_YAML_UNLIKELY (tmp_int < static_cast<node_int_type>(std::numeric_limits<IntType>::min())) {
                throw exception("Integer value underflow detected.");
            }
            if FK_YAML_UNLIKELY (static_cast<node_int_type>(std::numeric_limits<IntType>::max()) < tmp_int) {
                throw exception("Integer value overflow detected.");
            }
        }

        return static_cast<IntType>(tmp_int);
    }
};

/// @brief from_node function for integers.
/// @note If node's value is null, boolean, or float, such a value is converted into an integer internally.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam IntegerType An integer value type.
/// @param n A node object.
/// @param i Storage for an integer value.
template <
    typename BasicNodeType, typename IntegerType,
    enable_if_t<conjunction<is_basic_node<BasicNodeType>, is_non_bool_integral<IntegerType>>::value, int> = 0>
inline void from_node(const BasicNodeType& n, IntegerType& i) {
    switch (n.get_type()) {
    case node_type::NULL_OBJECT:
        // nullptr is interpreted as 0
        i = static_cast<IntegerType>(0);
        break;
    case node_type::BOOLEAN:
        i = static_cast<bool>(n.as_bool()) ? static_cast<IntegerType>(1) : static_cast<IntegerType>(0);
        break;
    case node_type::INTEGER:
        i = from_node_int_helper<BasicNodeType, IntegerType>::convert(n);
        break;
    case node_type::FLOAT: {
        // int64_t should be safe to express the integer part of possible floating point types.
        const auto tmp_int = static_cast<int64_t>(n.as_float());

        // under/overflow check.
        if (std::is_same<IntegerType, uint64_t>::value) {
            if FK_YAML_UNLIKELY (tmp_int < 0) {
                throw exception("Integer value underflow detected.");
            }
        }
        else {
            if FK_YAML_UNLIKELY (tmp_int < static_cast<int64_t>(std::numeric_limits<IntegerType>::min())) {
                throw exception("Integer value underflow detected.");
            }
            if FK_YAML_UNLIKELY (static_cast<int64_t>(std::numeric_limits<IntegerType>::max()) < tmp_int) {
                throw exception("Integer value overflow detected.");
            }
        }

        i = static_cast<IntegerType>(tmp_int);
        break;
    }
    case node_type::SEQUENCE:
    case node_type::MAPPING:
    case node_type::STRING:
    default:
        throw type_error("The target node value type is not compatible with integer type.", n.get_type());
    }
}

/// @brief Helper struct for node-to-float conversion if FloatType is the node's floating point value type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam FloatType Target floating point value type (same as the BasicNodeType::float_number_type)
template <
    typename BasicNodeType, typename FloatType,
    bool = std::is_same<typename BasicNodeType::float_number_type, FloatType>::value>
struct from_node_float_helper {
    /// @brief Convert node's floating point value to the target floating point type.
    /// @param n A node object.
    /// @return A floating point value converted from the node's floating point value.
    static FloatType convert(const BasicNodeType& n) {
        return n.as_float();
    }
};

/// @brief Helper struct for node-to-float conversion if IntType is not the node's floating point value type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam FloatType Target floating point value type (different from BasicNodeType::float_number_type)
template <typename BasicNodeType, typename FloatType>
struct from_node_float_helper<BasicNodeType, FloatType, false> {
    /// @brief Convert node's floating point value to the target floating point type.
    /// @param n A node object.
    /// @return A floating point value converted from the node's floating point value.
    static FloatType convert(const BasicNodeType& n) {
        using node_float_type = typename BasicNodeType::float_number_type;
        auto tmp_float = n.as_float();

        // check if the value is an infinite number (either positive or negative)
        if (std::isinf(tmp_float)) {
            if (tmp_float == std::numeric_limits<node_float_type>::infinity()) {
                return std::numeric_limits<FloatType>::infinity();
            }

            return static_cast<FloatType>(-1.) * std::numeric_limits<FloatType>::infinity();
        }

        // check if the value is not a number
        if (std::isnan(tmp_float)) {
            return std::numeric_limits<FloatType>::quiet_NaN();
        }

        // check if the value is expressible as FloatType.
        if FK_YAML_UNLIKELY (tmp_float < std::numeric_limits<FloatType>::lowest()) {
            throw exception("Floating point value underflow detected.");
        }
        if FK_YAML_UNLIKELY (std::numeric_limits<FloatType>::max() < tmp_float) {
            throw exception("Floating point value overflow detected.");
        }

        return static_cast<FloatType>(tmp_float);
    }
};

/// @brief from_node function for floating point values.
/// @note If node's value is null, boolean, or integer, such a value is converted into a floating point internally.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam FloatType A floating point value type.
/// @param n A node object.
/// @param f Storage for a float point value.
template <
    typename BasicNodeType, typename FloatType,
    enable_if_t<conjunction<is_basic_node<BasicNodeType>, std::is_floating_point<FloatType>>::value, int> = 0>
inline void from_node(const BasicNodeType& n, FloatType& f) {
    switch (n.get_type()) {
    case node_type::NULL_OBJECT:
        // nullptr is interpreted as 0.0
        f = static_cast<FloatType>(0.);
        break;
    case node_type::BOOLEAN:
        f = static_cast<bool>(n.as_bool()) ? static_cast<FloatType>(1.) : static_cast<FloatType>(0.);
        break;
    case node_type::INTEGER:
        f = static_cast<FloatType>(n.as_int());
        break;
    case node_type::FLOAT:
        f = from_node_float_helper<BasicNodeType, FloatType>::convert(n);
        break;
    case node_type::SEQUENCE:
    case node_type::MAPPING:
    case node_type::STRING:
    default:
        throw type_error("The target node value type is not compatible with float number type.", n.get_type());
    }
}

/// @brief from_node function for BasicNodeType::string_type objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @param n A basic_node object.
/// @param s A string node value object.
template <typename BasicNodeType, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void from_node(const BasicNodeType& n, typename BasicNodeType::string_type& s) {
    if FK_YAML_UNLIKELY (!n.is_string()) {
        throw type_error("The target node value type is not string type.", n.get_type());
    }
    s = n.as_str();
}

/// @brief from_node function for compatible string type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatibleStringType A compatible string type.
/// @param n A basic_node object.
/// @param s A compatible string object.
template <
    typename BasicNodeType, typename CompatibleStringType,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>,
            negation<std::is_same<CompatibleStringType, typename BasicNodeType::string_type>>,
            disjunction<
                std::is_constructible<CompatibleStringType, const typename BasicNodeType::string_type&>,
                std::is_assignable<CompatibleStringType, const typename BasicNodeType::string_type&>>>::value,
        int> = 0>
inline void from_node(const BasicNodeType& n, CompatibleStringType& s) {
    if FK_YAML_UNLIKELY (!n.is_string()) {
        throw type_error("The target node value type is not string type.", n.get_type());
    }
    s = n.as_str();
}

/// @brief from_node function for std::pair objects whose element types must be either a basic_node template instance
/// type or a compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T The first type of the std::pair.
/// @tparam U The second type of the std::pair.
/// @param n A basic_node object.
/// @param p A std::pair object.
template <typename BasicNodeType, typename T, typename U, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline auto from_node(const BasicNodeType& n, std::pair<T, U>& p)
    -> decltype(std::declval<const BasicNodeType&>().template get_value<T>(), std::declval<const BasicNodeType&>().template get_value<U>(), void()) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    // call get_value_inplace(), not get_value(), since the storage to fill the result into is already created.
    n.at(0).get_value_inplace(p.first);
    n.at(1).get_value_inplace(p.second);
}

/// @brief concrete implementation of from_node function for std::tuple objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam ...Types The value types of std::tuple.
/// @tparam ...Idx Index sequence values for std::tuples value types.
/// @param n A basic_node object
/// @param _ Index sequence values (unused).
/// @return A std::tuple object converted from the sequence node values.
template <typename BasicNodeType, typename... Types, std::size_t... Idx>
inline std::tuple<Types...> from_node_tuple_impl(const BasicNodeType& n, index_sequence<Idx...> /*unused*/) {
    return std::make_tuple(n.at(Idx).template get_value<Types>()...);
}

/// @brief from_node function for std::tuple objects whose value types must all be either a basic_node template instance
/// type or a compatible type
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam ...Types Value types of std::tuple.
/// @param n A basic_node object.
/// @param t A std::tuple object.
template <typename BasicNodeType, typename... Types, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void from_node(const BasicNodeType& n, std::tuple<Types...>& t) {
    if FK_YAML_UNLIKELY (!n.is_sequence()) {
        throw type_error("The target node value type is not sequence type.", n.get_type());
    }

    // Types... must be explicitly specified; the return type would otherwise be std::tuple with no value types.
    t = from_node_tuple_impl<BasicNodeType, Types...>(n, index_sequence_for<Types...> {});
}

#ifdef FK_YAML_HAS_CXX_17

/// @brief from_node function for std::optional objects whose value type must be either a basic_node template instance
/// type or a compatible type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A value type of the std::optional.
/// @param n A basic_node object.
/// @param o A std::optional object.
template <typename BasicNodeType, typename T, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline auto from_node(const BasicNodeType& n, std::optional<T>& o) -> decltype(n.template get_value<T>(), void()) {
    try {
        o.emplace(n.template get_value<T>());
    }
    catch (const std::exception& /*unused*/) {
        // Any exception derived from std::exception is interpreted as a conversion failure in some way
        // since user-defined from_node function may throw a different object from a fkyaml::type_error.
        // and std::exception is usually the base class of user-defined exception types.
        o = std::nullopt;
    }
}

#endif // defined(FK_YAML_HAS_CXX_17)

/// @brief A function object to call from_node functions.
/// @note User-defined specialization is available by providing implementation **OUTSIDE** fkyaml namespace.
struct from_node_fn {
    /// @brief Call from_node function suitable for the given T type.
    /// @tparam BasicNodeType A basic_node template instance type.
    /// @tparam T A target value type assigned from the basic_node object.
    /// @param n A basic_node object.
    /// @param val A target object assigned from the basic_node object.
    /// @return decltype(from_node(n, std::forward<T>(val))) void by default. User can set it to some other type.
    template <typename BasicNodeType, typename T>
    auto operator()(const BasicNodeType& n, T&& val) const
        noexcept(noexcept(from_node(n, std::forward<T>(val)))) -> decltype(from_node(n, std::forward<T>(val))) {
        return from_node(n, std::forward<T>(val));
    }
};

FK_YAML_DETAIL_NAMESPACE_END

FK_YAML_NAMESPACE_BEGIN

#ifndef FK_YAML_HAS_CXX_17
// anonymous namespace to hold `from_node` functor.
// see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html for why it's needed.
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
{
#endif

/// @brief A global object to represent ADL friendly from_node functor.
// NOLINTNEXTLINE(misc-definitions-in-headers)
FK_YAML_INLINE_VAR constexpr const auto& from_node = detail::static_const<detail::from_node_fn>::value;

#ifndef FK_YAML_HAS_CXX_17
} // namespace
#endif

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_DETAIL_CONVERSIONS_FROM_NODE_HPP */

// #include <fkYAML/detail/conversions/to_node.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_DETAIL_CONVERSIONS_TO_NODE_HPP
#define FK_YAML_DETAIL_CONVERSIONS_TO_NODE_HPP

#include <utility>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/exception_safe_allocation.hpp>

// #include <fkYAML/detail/meta/node_traits.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/detail/meta/stl_supplement.hpp>

// #include <fkYAML/detail/node_attrs.hpp>

// #include <fkYAML/node_type.hpp>


FK_YAML_DETAIL_NAMESPACE_BEGIN

///////////////////////////////////
//   external_node_constructor   //
///////////////////////////////////

/// @brief The external constructor template for basic_node objects.
/// @note All the non-specialized instantiations results in compilation error since such instantiations are not
/// supported.
/// @warning All the specialization must call n.m_value.destroy() first in the construct function to avoid
/// memory leak.
/// @tparam node_type The resulting YAML node value type.
template <typename BasicNodeType>
struct external_node_constructor {
    template <typename... Args>
    static void sequence(BasicNodeType& n, Args&&... args) {
        destroy(n);
        n.m_attrs |= node_attr_bits::seq_bit;
        n.m_value.p_seq = create_object<typename BasicNodeType::sequence_type>(std::forward<Args>(args)...);
    }

    template <typename... Args>
    static void mapping(BasicNodeType& n, Args&&... args) {
        destroy(n);
        n.m_attrs |= node_attr_bits::map_bit;
        n.m_value.p_map = create_object<typename BasicNodeType::mapping_type>(std::forward<Args>(args)...);
    }

    static void null_scalar(BasicNodeType& n, std::nullptr_t) {
        destroy(n);
        n.m_attrs |= node_attr_bits::null_bit;
        n.m_value.p_map = nullptr;
    }

    static void boolean_scalar(BasicNodeType& n, const typename BasicNodeType::boolean_type b) {
        destroy(n);
        n.m_attrs |= node_attr_bits::bool_bit;
        n.m_value.boolean = b;
    }

    static void integer_scalar(BasicNodeType& n, const typename BasicNodeType::integer_type i) {
        destroy(n);
        n.m_attrs |= node_attr_bits::int_bit;
        n.m_value.integer = i;
    }

    static void float_scalar(BasicNodeType& n, const typename BasicNodeType::float_number_type f) {
        destroy(n);
        n.m_attrs |= node_attr_bits::float_bit;
        n.m_value.float_val = f;
    }

    template <typename... Args>
    static void string_scalar(BasicNodeType& n, Args&&... args) {
        destroy(n);
        n.m_attrs |= node_attr_bits::string_bit;
        n.m_value.p_str = create_object<typename BasicNodeType::string_type>(std::forward<Args>(args)...);
    }

private:
    static void destroy(BasicNodeType& n) {
        n.m_value.destroy(n.m_attrs & node_attr_mask::value);
        n.m_attrs &= ~node_attr_mask::value;
    }
};

/////////////////
//   to_node   //
/////////////////

/// @brief to_node function for BasicNodeType::sequence_type objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A sequence node value type.
/// @param n A basic_node object.
/// @param s A sequence node value object.
template <
    typename BasicNodeType, typename T,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>,
            std::is_same<typename BasicNodeType::sequence_type, remove_cvref_t<T>>>::value,
        int> = 0>
inline void to_node(BasicNodeType& n, T&& s) noexcept {
    external_node_constructor<BasicNodeType>::sequence(n, std::forward<T>(s));
}

/// @brief to_node function for compatible sequence types.
/// @note This overload is enabled when
/// * both begin()/end() functions are callable on a `CompatSeqType` object
/// * CompatSeqType doesn't have `mapped_type` (mapping-like type)
/// * BasicNodeType::string_type cannot be constructed from a CompatSeqType object (string-like type)
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatSeqType A container type.
/// @param n A basic_node object.
/// @param s A container object.
template <
    typename BasicNodeType, typename CompatSeqType,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>,
            negation<std::is_same<typename BasicNodeType::sequence_type, remove_cvref_t<CompatSeqType>>>,
            negation<is_basic_node<CompatSeqType>>, detect::has_begin_end<CompatSeqType>,
            negation<conjunction<detect::has_key_type<CompatSeqType>, detect::has_mapped_type<CompatSeqType>>>,
            negation<std::is_constructible<typename BasicNodeType::string_type, CompatSeqType>>>::value,
        int> = 0>
// NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
inline void to_node(BasicNodeType& n, CompatSeqType&& s) {
    using std::begin;
    using std::end;
    external_node_constructor<BasicNodeType>::sequence(n, begin(s), end(s));
}

/// @brief to_node function for std::pair objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T The first type of std::pair.
/// @tparam U The second type of std::pair.
/// @param n A basic_node object.
/// @param p A std::pair object.
template <typename BasicNodeType, typename T, typename U>
inline void to_node(BasicNodeType& n, const std::pair<T, U>& p) {
    n = {p.first, p.second};
}

/// @brief concrete implementation of to_node function for std::tuple objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam ...Types The value types of std::tuple.
/// @tparam ...Idx Index sequence values for std::tuple value types.
/// @param n A basic_node object.
/// @param t A std::tuple object.
/// @param _ An index sequence. (unused)
template <typename BasicNodeType, typename... Types, std::size_t... Idx>
inline void to_node_tuple_impl(BasicNodeType& n, const std::tuple<Types...>& t, index_sequence<Idx...> /*unused*/) {
    n = {std::get<Idx>(t)...};
}

/// @brief to_node function for std::tuple objects with no value types.
/// @note This implementation is needed since calling `to_node_tuple_impl()` with an empty tuple creates a null node.
/// @tparam BasicNodeType A basic_node template instance type.
/// @param n A basic_node object.
/// @param _ A std::tuple object. (unused)
template <typename BasicNodeType>
inline void to_node(BasicNodeType& n, const std::tuple<>& /*unused*/) {
    n = BasicNodeType::sequence();
}

/// @brief to_node function for std::tuple objects with at least one value type.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam ...FirstType The first value types of std::tuple.
/// @tparam ...RestTypes The rest value types of std::tuple. (maybe empty)
/// @param n A basic_node object.
/// @param t A std::tuple object.
template <typename BasicNodeType, typename FirstType, typename... RestTypes>
inline void to_node(BasicNodeType& n, const std::tuple<FirstType, RestTypes...>& t) {
    to_node_tuple_impl(n, t, index_sequence_for<FirstType, RestTypes...> {});
}

/// @brief to_node function for BasicNodeType::mapping_type objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A mapping node value type.
/// @param n A basic_node object.
/// @param m A mapping node value object.
template <
    typename BasicNodeType, typename T,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>, std::is_same<typename BasicNodeType::mapping_type, remove_cvref_t<T>>>::value,
        int> = 0>
inline void to_node(BasicNodeType& n, T&& m) noexcept {
    external_node_constructor<BasicNodeType>::mapping(n, std::forward<T>(m));
}

/// @brief to_node function for compatible mapping types.
/// @note This overload is enabled when
/// * both begin()/end() functions are callable on a `CompatMapType` object
/// * CompatMapType has both `key_type` and `mapped_type`
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam CompatMapType A container type.
/// @param n A basic_node object.
/// @param m A container object.
template <
    typename BasicNodeType, typename CompatMapType,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>, negation<is_basic_node<CompatMapType>>,
            negation<std::is_same<typename BasicNodeType::mapping_type, remove_cvref_t<CompatMapType>>>,
            detect::has_begin_end<CompatMapType>, detect::has_key_type<CompatMapType>,
            detect::has_mapped_type<CompatMapType>>::value,
        int> = 0>
inline void to_node(BasicNodeType& n, CompatMapType&& m) {
    external_node_constructor<BasicNodeType>::mapping(n);
    auto& map = n.as_map();
    for (const auto& pair : std::forward<CompatMapType>(m)) {
        map.emplace(pair.first, pair.second);
    }
}

/// @brief to_node function for null objects.
/// @tparam BasicNodeType A mapping node value type.
/// @tparam NullType This must be std::nullptr_t type
template <typename BasicNodeType, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void to_node(BasicNodeType& n, std::nullptr_t /*unused*/) {
    external_node_constructor<BasicNodeType>::null_scalar(n, nullptr);
}

/// @brief to_node function for BasicNodeType::boolean_type objects.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A boolean scalar node value type.
/// @param n A basic_node object.
/// @param b A boolean scalar node value object.
template <typename BasicNodeType, enable_if_t<is_basic_node<BasicNodeType>::value, int> = 0>
inline void to_node(BasicNodeType& n, typename BasicNodeType::boolean_type b) noexcept {
    external_node_constructor<BasicNodeType>::boolean_scalar(n, b);
}

/// @brief to_node function for integers.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T An integer type.
/// @param n A basic_node object.
/// @param i An integer object.
template <
    typename BasicNodeType, typename T,
    enable_if_t<conjunction<is_basic_node<BasicNodeType>, is_non_bool_integral<T>>::value, int> = 0>
inline void to_node(BasicNodeType& n, T i) noexcept {
    external_node_constructor<BasicNodeType>::integer_scalar(n, i);
}

/// @brief to_node function for floating point numbers.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A floating point number type.
/// @param n A basic_node object.
/// @param f A floating point number object.
template <
    typename BasicNodeType, typename T,
    enable_if_t<conjunction<is_basic_node<BasicNodeType>, std::is_floating_point<T>>::value, int> = 0>
inline void to_node(BasicNodeType& n, T f) noexcept {
    external_node_constructor<BasicNodeType>::float_scalar(n, f);
}

/// @brief to_node function for compatible strings.
/// @tparam BasicNodeType A basic_node template instance type.
/// @tparam T A compatible string type.
/// @param n A basic_node object.
/// @param s A compatible string object.
template <
    typename BasicNodeType, typename T,
    enable_if_t<
        conjunction<
            is_basic_node<BasicNodeType>, negation<is_null_pointer<T>>,
            std::is_constructible<typename BasicNodeType::string_type, T>>::value,
        int> = 0>
inline void to_node(BasicNodeType& n, T&& s) {
    external_node_constructor<BasicNodeType>::string_scalar(n, std::forward<T>(s));
}

/// @brief A function object to call to_node functions.
/// @note User-defined specialization is available by providing implementation **OUTSIDE** fkyaml namespace.
struct to_node_fn {
    /// @brief Call to_node function suitable for the given T type.
    /// @tparam BasicNodeType A basic_node template instance type.
    /// @tparam T A target value type assigned to the basic_node object.
    /// @param n A basic_node object.
    /// @param val A target object assigned to the basic_node object.
    /// @return decltype(to_node(n, std::forward<T>(val))) void by default. User can set it to some other type.
    template <typename BasicNodeType, typename T>
    auto operator()(BasicNodeType& n, T&& val) const
        noexcept(noexcept(to_node(n, std::forward<T>(val)))) -> decltype(to_node(n, std::forward<T>(val))) {
        return to_node(n, std::forward<T>(val));
    }
};

FK_YAML_DETAIL_NAMESPACE_END

FK_YAML_NAMESPACE_BEGIN

#ifndef FK_YAML_HAS_CXX_17
// anonymous namespace to hold `to_node` functor.
// see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html for why it's needed.
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
{
#endif

/// @brief A global object to represent ADL friendly to_node functor.
// NOLINTNEXTLINE(misc-definitions-in-headers)
FK_YAML_INLINE_VAR constexpr const auto& to_node = detail::static_const<detail::to_node_fn>::value;

#ifndef FK_YAML_HAS_CXX_17
} // namespace
#endif

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_DETAIL_CONVERSIONS_TO_NODE_HPP */


FK_YAML_NAMESPACE_BEGIN

/// @brief An ADL friendly converter between basic_node objects and native data objects.
/// @tparam ValueType A default target data type.
/// @sa https://fktn-k.github.io/fkYAML/api/node_value_converter/
template <typename ValueType, typename>
class node_value_converter {
public:
    /// @brief Convert a YAML node value into compatible native data.
    /// @tparam BasicNodeType A basic_node template instance type.
    /// @tparam TargetType A native data type for conversion.
    /// @param n A basic_node object.
    /// @param val A native data object.
    /// @sa https://fktn-k.github.io/fkYAML/api/node_value_converter/from_node/
    template <typename BasicNodeType, typename TargetType = ValueType>
    static auto from_node(BasicNodeType&& n, TargetType& val) noexcept(
        noexcept(::fkyaml::from_node(std::forward<BasicNodeType>(n), val)))
        -> decltype(::fkyaml::from_node(std::forward<BasicNodeType>(n), val), void()) {
        ::fkyaml::from_node(std::forward<BasicNodeType>(n), val);
    }

    /// @brief Convert compatible native data into a YAML node.
    /// @tparam BasicNodeType A basic_node template instance type.
    /// @tparam TargetType A native data type for conversion.
    /// @param n A basic_node object.
    /// @param val A native data object.
    /// @sa https://fktn-k.github.io/fkYAML/api/node_value_converter/to_node/
    template <typename BasicNodeType, typename TargetType = ValueType>
    static auto to_node(BasicNodeType& n, TargetType&& val) noexcept(noexcept(::fkyaml::to_node(
        n, std::forward<TargetType>(val)))) -> decltype(::fkyaml::to_node(n, std::forward<TargetType>(val))) {
        ::fkyaml::to_node(n, std::forward<TargetType>(val));
    }
};

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_NODE_VALUE_CONVERTER_HPP */

// #include <fkYAML/ordered_map.hpp>
//  _______   __ __   __  _____   __  __  __
// |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML library
// |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
// |__|  |_| \__|  |_|  |_|   |_|___||___|______| https://github.com/fktn-k/fkYAML
//
// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
// SPDX-License-Identifier: MIT

#ifndef FK_YAML_ORDERED_MAP_HPP
#define FK_YAML_ORDERED_MAP_HPP

#include <functional>
#include <initializer_list>
#include <memory>
#include <utility>
#include <vector>

// #include <fkYAML/detail/macros/define_macros.hpp>

// #include <fkYAML/detail/meta/type_traits.hpp>

// #include <fkYAML/exception.hpp>


FK_YAML_NAMESPACE_BEGIN

/// @brief A minimal map-like container which preserves insertion order.
/// @tparam Key A type for keys.
/// @tparam Value A type for values.
/// @tparam IgnoredCompare A placeholder for key comparison. This will be ignored.
/// @tparam Allocator A class for allocators.
/// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
template <
    typename Key, typename Value, typename IgnoredCompare = std::less<Key>,
    typename Allocator = std::allocator<std::pair<const Key, Value>>>
class ordered_map : public std::vector<std::pair<const Key, Value>, Allocator> {
public:
    /// @brief A type for keys.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using key_type = Key;

    /// @brief A type for values.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using mapped_type = Value;

    /// @brief A type for internal key-value containers.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using Container = std::vector<std::pair<const Key, Value>, Allocator>;

    /// @brief A type for key-value pairs.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using value_type = typename Container::value_type;

    /// @brief A type for non-const iterators.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using iterator = typename Container::iterator;

    /// @brief A type for const iterators.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using const_iterator = typename Container::const_iterator;

    /// @brief A type for size parameters used in this class.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using size_type = typename Container::size_type;

    /// @brief A type for comparison between keys.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/
    using key_compare = std::equal_to<Key>;

public:
    /// @brief Construct a new ordered_map object.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/constructor/
    ordered_map() noexcept(noexcept(Container()))
        : Container() {
    }

    /// @brief Construct a new ordered_map object with an initializer list.
    /// @param init An initializer list to construct the inner container object.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/constructor/
    ordered_map(std::initializer_list<value_type> init)
        : Container {init} {
    }

public:
    /// @brief A subscript operator for ordered_map objects.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to the target value.
    /// @return mapped_type& Reference to a mapped_type object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/operator[]/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    mapped_type& operator[](KeyType&& key) noexcept {
        return emplace(std::forward<KeyType>(key), mapped_type()).first->second;
    }

public:
    /// @brief Emplace a new key-value pair if the new key does not exist.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to be emplaced to this ordered_map object.
    /// @param value A value to be emplaced to this ordered_map object.
    /// @return std::pair<iterator, bool> A result of emplacement of the new key-value pair.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/emplace/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    std::pair<iterator, bool> emplace(KeyType&& key, const mapped_type& value) noexcept {
        for (auto itr = this->begin(); itr != this->end(); ++itr) {
            if (m_compare(itr->first, key)) {
                return {itr, false};
            }
        }
        this->emplace_back(std::forward<KeyType>(key), value);
        return {std::prev(this->end()), true};
    }

    /// @brief Find a value associated to the given key. Throws an exception if the search fails.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to find a value with.
    /// @return mapped_type& The value associated to the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/at/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    mapped_type& at(KeyType&& key) { // NOLINT(cppcoreguidelines-missing-std-forward)
        for (auto itr = this->begin(); itr != this->end(); ++itr) {
            if (m_compare(itr->first, key)) {
                return itr->second;
            }
        }
        throw fkyaml::exception("key not found.");
    }

    /// @brief Find a value associated to the given key. Throws an exception if the search fails.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to find a value with.
    /// @return const mapped_type& The value associated to the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/at/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    const mapped_type& at(KeyType&& key) const { // NOLINT(cppcoreguidelines-missing-std-forward)
        for (auto itr = this->begin(); itr != this->end(); ++itr) {
            if (m_compare(itr->first, key)) {
                return itr->second;
            }
        }
        throw fkyaml::exception("key not found.");
    }

    /// @brief Find a value with the given key.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to find a value with.
    /// @return iterator The iterator for the found value, or the result of end().
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/find/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    iterator find(KeyType&& key) noexcept { // NOLINT(cppcoreguidelines-missing-std-forward)
        for (auto itr = this->begin(); itr != this->end(); ++itr) {
            if (m_compare(itr->first, key)) {
                return itr;
            }
        }
        return this->end();
    }

    /// @brief Find a value with the given key.
    /// @tparam KeyType A type for the input key.
    /// @param key A key to find a value with.
    /// @return const_iterator The constant iterator for the found value, or the result of end().
    /// @sa https://fktn-k.github.io/fkYAML/api/ordered_map/find/
    template <
        typename KeyType,
        detail::enable_if_t<detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    const_iterator find(KeyType&& key) const noexcept { // NOLINT(cppcoreguidelines-missing-std-forward)
        for (auto itr = this->begin(); itr != this->end(); ++itr) {
            if (m_compare(itr->first, key)) {
                return itr;
            }
        }
        return this->end();
    }

private:
    /// The object for comparing keys.
    key_compare m_compare {};
};

FK_YAML_NAMESPACE_END

#endif /* FK_YAML_ORDERED_MAP_HPP */


FK_YAML_NAMESPACE_BEGIN

/// @brief A class to store value of YAML nodes.
/// @sa https://fktn-k.github.io/fkYAML/api/basic_node/
template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename = void> class ConverterType>
class basic_node {
public:
    /// @brief A type for sequence basic_node values.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/sequence_type/
    using sequence_type = SequenceType<basic_node, std::allocator<basic_node>>;

    /// @brief A type for mapping basic_node values.
    /// @note std::unordered_map is not supported since it does not allow incomplete types.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/mapping_type/
    using mapping_type = MappingType<basic_node, basic_node>;

    /// @brief A type for boolean basic_node values.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/boolean_type/
    using boolean_type = BooleanType;

    /// @brief A type for integer basic_node values.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/integer_type/
    using integer_type = IntegerType;

    /// @brief A type for float number basic_node values.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/float_number_type/
    using float_number_type = FloatNumberType;

    /// @brief A type for string basic_node values.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/string_type/
    using string_type = StringType;

    /// @brief A type of elements in a basic_node container.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using value_type = basic_node;

    /// @brief A type of reference to a basic_node element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using reference = value_type&;

    /// @brief A type of constant reference to a basic_node element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using const_reference = const value_type&;

    /// @brief A type of a pointer to a basic_node element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using pointer = value_type*;

    /// @brief A type of a constant pointer to a basic_node element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using const_pointer = const value_type*;

    /// @brief A type to represent basic_node container sizes.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using size_type = std::size_t;

    /// @brief A type to represent differences between basic_node iterators.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/#container-types
    using difference_type = std::ptrdiff_t;

    /// @brief A type for iterators of basic_node containers.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/iterator/
    using iterator = fkyaml::detail::iterator<basic_node>;

    /// @brief A type for constant iterators of basic_node containers.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/iterator/
    using const_iterator = fkyaml::detail::iterator<const basic_node>;

    /// @brief A type for reverse iterators of basic_node containers.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/reverse_iterator/
    using reverse_iterator = fkyaml::detail::reverse_iterator<iterator>;

    /// @brief A type for constant reverse iterators of basic_node containers.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/reverse_iterator/
    using const_reverse_iterator = fkyaml::detail::reverse_iterator<const_iterator>;

    /// @brief A helper alias to determine converter type for the given target native data type.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/value_converter_type/
    template <typename T, typename SFINAE>
    using value_converter_type = ConverterType<T, SFINAE>;

    /// @brief Definition of node value types.
    /// @deprecated Use fkyaml::node_type enum class. (since 0.3.12)
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/node_t/
    using node_t = detail::node_t;

    /// @brief Definition of YAML version types.
    /// @deprecated Use fkyaml::yaml_version_type enum class. (since 0.3.12)
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/yaml_version_t/
    using yaml_version_t = detail::yaml_version_t;

    /// @brief A type for mapping range objects for the map_items() function.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/map_range/
    using map_range = fkyaml::detail::map_range_proxy<basic_node>;

    /// @brief A type for constant mapping range objects for the map_items() function.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/map_range/
    using const_map_range = fkyaml::detail::map_range_proxy<const basic_node>;

private:
    template <typename BasicNodeType>
    friend struct fkyaml::detail::external_node_constructor;

    template <typename BasicNodeType>
    friend class fkyaml::detail::basic_deserializer;

    template <typename BasicNodeType>
    friend class fkyaml::detail::basic_serializer;

    /// @brief A type for YAML docs deserializers.
    using deserializer_type = detail::basic_deserializer<basic_node>;
    /// @brief A type for YAML docs serializers.
    using serializer_type = detail::basic_serializer<basic_node>;
    /// @brief A helper type alias for std::initializer_list.
    using initializer_list_t = std::initializer_list<detail::node_ref_storage<basic_node>>;

    /// @brief The actual storage for a YAML node value of the @ref basic_node class.
    /// @details This union combines the different storage types for the YAML value types defined in @ref node_t.
    /// @note Container types are stored as pointers so that the size of this union will not exceed 64 bits by
    /// default.
    union node_value {
        /// @brief Constructs a new basic_node Value object for null types.
        node_value() = default;

        /// @brief Constructs a new basic_node value object with a node type. The default value for the specified
        /// type will be assigned.
        /// @param[in] type A node type.
        explicit node_value(detail::node_attr_t value_type_bit) {
            switch (value_type_bit) {
            case detail::node_attr_bits::seq_bit:
                p_seq = detail::create_object<sequence_type>();
                break;
            case detail::node_attr_bits::map_bit:
                p_map = detail::create_object<mapping_type>();
                break;
            case detail::node_attr_bits::null_bit:
                p_map = nullptr;
                break;
            case detail::node_attr_bits::bool_bit:
                boolean = static_cast<boolean_type>(false);
                break;
            case detail::node_attr_bits::int_bit:
                integer = static_cast<integer_type>(0);
                break;
            case detail::node_attr_bits::float_bit:
                float_val = static_cast<float_number_type>(0.0);
                break;
            case detail::node_attr_bits::string_bit:
                p_str = detail::create_object<string_type>();
                break;
            default:                   // LCOV_EXCL_LINE
                detail::unreachable(); // LCOV_EXCL_LINE
            }
        }

        /// @brief Destroys the existing Node value. This process is recursive if the specified node type is for
        /// containers.
        /// @param[in] type A Node type to determine the value to be destroyed.
        void destroy(detail::node_attr_t value_type_bit) {
            switch (value_type_bit) {
            case detail::node_attr_bits::seq_bit:
                p_seq->clear();
                detail::destroy_object<sequence_type>(p_seq);
                p_seq = nullptr;
                break;
            case detail::node_attr_bits::map_bit:
                p_map->clear();
                detail::destroy_object<mapping_type>(p_map);
                p_map = nullptr;
                break;
            case detail::node_attr_bits::string_bit:
                detail::destroy_object<string_type>(p_str);
                p_str = nullptr;
                break;
            default:
                break;
            }
        }

        /// A pointer to the value of sequence type.
        sequence_type* p_seq;
        /// A pointer to the value of mapping type. This pointer is also used when node type is null.
        mapping_type* p_map {nullptr};
        /// A value of boolean type.
        boolean_type boolean;
        /// A value of integer type.
        integer_type integer;
        /// A value of float number type.
        float_number_type float_val;
        /// A pointer to the value of string type.
        string_type* p_str;
    };

public:
    /// @brief Constructs a new basic_node object of null type.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    basic_node() = default;

    /// @brief Constructs a new basic_node object with a specified type.
    /// @param[in] type A YAML node type.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    FK_YAML_DEPRECATED("Since 0.3.12; Use explicit basic_node(const node_type)")
    explicit basic_node(const node_t type)
        : basic_node(detail::convert_to_node_type(type)) {
    }

    explicit basic_node(const node_type type)
        : m_attrs(detail::node_attr_bits::from_node_type(type)),
          m_value(m_attrs & detail::node_attr_mask::value) {
    }

    /// @brief Copy constructor of the basic_node class.
    /// @param[in] rhs A basic_node object to be copied with.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    basic_node(const basic_node& rhs)
        : m_attrs(rhs.m_attrs),
          mp_meta(rhs.mp_meta),
          m_prop(rhs.m_prop) {
        if FK_YAML_LIKELY (!has_anchor_name()) {
            switch (m_attrs & detail::node_attr_mask::value) {
            case detail::node_attr_bits::seq_bit:
                m_value.p_seq = detail::create_object<sequence_type>(*(rhs.m_value.p_seq));
                break;
            case detail::node_attr_bits::map_bit:
                m_value.p_map = detail::create_object<mapping_type>(*(rhs.m_value.p_map));
                break;
            case detail::node_attr_bits::null_bit:
                m_value.p_map = nullptr;
                break;
            case detail::node_attr_bits::bool_bit:
                m_value.boolean = rhs.m_value.boolean;
                break;
            case detail::node_attr_bits::int_bit:
                m_value.integer = rhs.m_value.integer;
                break;
            case detail::node_attr_bits::float_bit:
                m_value.float_val = rhs.m_value.float_val;
                break;
            case detail::node_attr_bits::string_bit:
                m_value.p_str = detail::create_object<string_type>(*(rhs.m_value.p_str));
                break;
            default:                   // LCOV_EXCL_LINE
                detail::unreachable(); // LCOV_EXCL_LINE
            }
        }
    }

    /// @brief Move constructor of the basic_node class.
    /// @param[in] rhs A basic_node object to be moved from.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    basic_node(basic_node&& rhs) noexcept
        : m_attrs(rhs.m_attrs),
          mp_meta(std::move(rhs.mp_meta)),
          m_prop(std::move(rhs.m_prop)) {
        if FK_YAML_LIKELY (!has_anchor_name()) {
            switch (m_attrs & detail::node_attr_mask::value) {
            case detail::node_attr_bits::seq_bit:
                FK_YAML_ASSERT(rhs.m_value.p_seq != nullptr);
                m_value.p_seq = rhs.m_value.p_seq;
                rhs.m_value.p_seq = nullptr;
                break;
            case detail::node_attr_bits::map_bit:
                FK_YAML_ASSERT(rhs.m_value.p_map != nullptr);
                m_value.p_map = rhs.m_value.p_map;
                rhs.m_value.p_map = nullptr;
                break;
            case detail::node_attr_bits::null_bit:
                FK_YAML_ASSERT(rhs.m_value.p_map == nullptr);
                m_value.p_map = rhs.m_value.p_map;
                break;
            case detail::node_attr_bits::bool_bit:
                m_value.boolean = rhs.m_value.boolean;
                rhs.m_value.boolean = static_cast<boolean_type>(false);
                break;
            case detail::node_attr_bits::int_bit:
                m_value.integer = rhs.m_value.integer;
                rhs.m_value.integer = static_cast<integer_type>(0);
                break;
            case detail::node_attr_bits::float_bit:
                m_value.float_val = rhs.m_value.float_val;
                rhs.m_value.float_val = static_cast<float_number_type>(0.0);
                break;
            case detail::node_attr_bits::string_bit:
                FK_YAML_ASSERT(rhs.m_value.p_str != nullptr);
                m_value.p_str = rhs.m_value.p_str;
                rhs.m_value.p_str = nullptr;
                break;
            default:                   // LCOV_EXCL_LINE
                detail::unreachable(); // LCOV_EXCL_LINE
            }
        }

        rhs.m_attrs = detail::node_attr_bits::default_bits;
        rhs.m_value.p_map = nullptr;
    }

    /// @brief Construct a new basic_node object from a value of compatible types.
    /// @tparam CompatibleType Type of native data which is compatible with node values.
    /// @tparam U Type of compatible native data without cv-qualifiers and reference.
    /// @param[in] val The value of a compatible type.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    template <
        typename CompatibleType, typename U = detail::remove_cvref_t<CompatibleType>,
        detail::enable_if_t<
            detail::conjunction<
                detail::negation<detail::is_basic_node<U>>,
                detail::disjunction<detail::is_node_compatible_type<basic_node, U>>>::value,
            int> = 0>
    basic_node(CompatibleType&& val) noexcept(
        noexcept(ConverterType<U, void>::to_node(std::declval<basic_node&>(), std::declval<CompatibleType>()))) {
        ConverterType<U, void>::to_node(*this, std::forward<CompatibleType>(val));
    }

    /// @brief Construct a new basic node object with a node_ref_storage object.
    /// @tparam NodeRefStorageType Type of basic_node with reference.
    /// @param[in] node_ref_storage A node_ref_storage template class object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    template <
        typename NodeRefStorageType,
        detail::enable_if_t<detail::is_node_ref_storage<NodeRefStorageType>::value, int> = 0>
    basic_node(const NodeRefStorageType& node_ref_storage) noexcept
        : basic_node(node_ref_storage.release()) {
    }

    /// @brief Construct a new basic node object with std::initializer_list.
    /// @param[in] init A initializer list of basic_node objects.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/constructor/
    basic_node(initializer_list_t init) {
        bool is_mapping =
            std::all_of(init.begin(), init.end(), [](const detail::node_ref_storage<basic_node>& node_ref) {
                // Do not use is_sequence_impl() since node_ref may be an anchor or alias.
                return node_ref->is_sequence() && node_ref->size() == 2;
            });

        if (is_mapping) {
            m_attrs = detail::node_attr_bits::map_bit;
            m_value.p_map = detail::create_object<mapping_type>();

            auto& map = *m_value.p_map;
            for (auto& elem_ref : init) {
                auto elem = elem_ref.release();
                auto& seq = *elem.m_value.p_seq;
                map.emplace(std::move(seq[0]), std::move(seq[1]));
            }
        }
        else {
            m_attrs = detail::node_attr_bits::seq_bit;
            m_value.p_seq = detail::create_object<sequence_type>();

            auto& seq = *m_value.p_seq;
            seq.reserve(std::distance(init.begin(), init.end()));
            for (auto& elem_ref : init) {
                seq.emplace_back(std::move(elem_ref.release()));
            }
        }
    }

    /// @brief Destroy the basic_node object and its value storage.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/destructor/
    ~basic_node() noexcept // NOLINT(bugprone-exception-escape)
    {
        if (m_attrs & detail::node_attr_mask::anchoring) {
            if (m_attrs & detail::node_attr_bits::anchor_bit) {
                auto itr = mp_meta->anchor_table.equal_range(m_prop.anchor).first;
                std::advance(itr, detail::node_attr_bits::get_anchor_offset(m_attrs));
                itr->second.m_value.destroy(itr->second.m_attrs & detail::node_attr_mask::value);
                itr->second.m_attrs = detail::node_attr_bits::default_bits;
                itr->second.mp_meta.reset();
            }
        }
        else if ((m_attrs & detail::node_attr_bits::null_bit) == 0) {
            m_value.destroy(m_attrs & detail::node_attr_mask::value);
        }

        m_attrs = detail::node_attr_bits::default_bits;
        mp_meta.reset();
    }

public:
    /// @brief Deserialize the first YAML document in the input into a basic_node object.
    /// @tparam InputType Type of a compatible input.
    /// @param[in] input An input source in the YAML format.
    /// @return The resulting basic_node object deserialized from the input source.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/deserialize/
    template <typename InputType>
    static basic_node deserialize(InputType&& input) {
        return deserializer_type().deserialize(detail::input_adapter(std::forward<InputType>(input)));
    }

    /// @brief Deserialize the first YAML document in the input ranged by the iterators into a basic_node object.
    /// @note
    /// Iterators must satisfy the LegacyInputIterator requirements.
    /// See https://en.cppreference.com/w/cpp/named_req/InputIterator.
    /// @tparam ItrType Type of a compatible iterator
    /// @param[in] begin An iterator to the first element of an input sequence.
    /// @param[in] end An iterator to the past-the-last element of an input sequence.
    /// @return The resulting basic_node object deserialized from the pair of iterators.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/deserialize/
    template <typename ItrType>
    static basic_node deserialize(ItrType begin, ItrType end) {
        return deserializer_type().deserialize(
            detail::input_adapter(std::forward<ItrType>(begin), std::forward<ItrType>(end)));
    }

    /// @brief Deserialize all YAML documents in the input into basic_node objects.
    /// @tparam InputType Type of a compatible input.
    /// @param[in] input An input source in the YAML format.
    /// @return The resulting basic_node objects deserialized from the input.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/deserialize_docs/
    template <typename InputType>
    static std::vector<basic_node> deserialize_docs(InputType&& input) {
        return deserializer_type().deserialize_docs(detail::input_adapter(std::forward<InputType>(input)));
    }

    /// @brief Deserialize all YAML documents in the input ranged by the iterators into basic_node objects.
    /// @tparam ItrType Type of a compatible iterator.
    /// @param[in] begin An iterator to the first element of an input sequence.
    /// @param[in] end An iterator to the past-the-last element of an input sequence.
    /// @return The resulting basic_node objects deserialized from the pair of iterators.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/deserialize_docs/
    template <typename ItrType>
    static std::vector<basic_node> deserialize_docs(ItrType&& begin, ItrType&& end) {
        return deserializer_type().deserialize_docs(
            detail::input_adapter(std::forward<ItrType>(begin), std::forward<ItrType>(end)));
    }

    /// @brief Serialize a basic_node object into a string.
    /// @param[in] node A basic_node object to be serialized.
    /// @return The resulting string object from the serialization of the given node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/serialize/
    static std::string serialize(const basic_node& node) {
        return serializer_type().serialize(node);
    }

    /// @brief Serialize basic_node objects into a string.
    /// @param docs basic_node objects to be serialized.
    /// @return The resulting string object from the serialization of the given nodes.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/serialize_docs/
    static std::string serialize_docs(const std::vector<basic_node>& docs) {
        return serializer_type().serialize_docs(docs);
    }

    /// @brief A factory method for sequence basic_node objects without sequence_type objects.
    /// @return A YAML sequence node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/sequence/
    static basic_node sequence() {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::seq_bit;
        node.m_value.p_seq = detail::create_object<sequence_type>();
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for sequence basic_node objects with lvalue sequence_type objects.
    /// @param[in] seq A lvalue sequence node value.
    /// @return A YAML sequence node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/sequence/
    static basic_node sequence(const sequence_type& seq) {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::seq_bit;
        node.m_value.p_seq = detail::create_object<sequence_type>(seq);
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for sequence basic_node objects with rvalue sequence_type objects.
    /// @param[in] seq A rvalue sequence node value.
    /// @return A YAML sequence node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/sequence/
    static basic_node sequence(sequence_type&& seq) {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::seq_bit;
        node.m_value.p_seq = detail::create_object<sequence_type>(std::move(seq));
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for mapping basic_node objects without mapping_type objects.
    /// @return A YAML mapping node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/mapping/
    static basic_node mapping() {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::map_bit;
        node.m_value.p_map = detail::create_object<mapping_type>();
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for mapping basic_node objects with lvalue mapping_type objects.
    /// @param[in] map A lvalue mapping node value.
    /// @return A YAML mapping node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/mapping/
    static basic_node mapping(const mapping_type& map) {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::map_bit;
        node.m_value.p_map = detail::create_object<mapping_type>(map);
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for mapping basic_node objects with rvalue mapping_type objects.
    /// @param[in] map A rvalue mapping node value.
    /// @return A YAML mapping node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/mapping/
    static basic_node mapping(mapping_type&& map) {
        basic_node node;
        node.m_attrs = detail::node_attr_bits::map_bit;
        node.m_value.p_map = detail::create_object<mapping_type>(std::move(map));
        return node;
    } // LCOV_EXCL_LINE

    /// @brief A factory method for alias basic_node objects referencing the given anchor basic_node object.
    /// @note The given anchor basic_node must have a non-empty anchor name.
    /// @param[in] anchor_node A basic_node object with an anchor name.
    /// @return An alias YAML node created from the given anchor node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/alias_of/
    static basic_node alias_of(const basic_node& anchor_node) {
        constexpr detail::node_attr_t anchor_bit = detail::node_attr_bits::anchor_bit;

        if FK_YAML_UNLIKELY (!anchor_node.has_anchor_name() || !(anchor_node.m_attrs & anchor_bit)) {
            throw fkyaml::exception("Cannot create an alias without anchor name.");
        }

        basic_node node = anchor_node;
        node.m_attrs &= ~detail::node_attr_mask::anchoring;
        node.m_attrs |= detail::node_attr_bits::alias_bit;
        return node;
    } // LCOV_EXCL_LINE

public:
    /// @brief A copy assignment operator of the basic_node class.
    /// @param[in] rhs A lvalue basic_node object to be copied with.
    /// @return Reference to this basic_node object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator=/
    basic_node& operator=(const basic_node& rhs) noexcept {
        basic_node(rhs).swap(*this);
        return *this;
    }

    /// @brief A move assignment operator of the basic_node class.
    /// @param[in] rhs A rvalue basic_node object to be moved from.
    /// @return Reference to this basic_node object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator=/
    basic_node& operator=(basic_node&& rhs) noexcept {
        basic_node(std::move(rhs)).swap(*this);
        return *this;
    }

    /// @brief A subscript operator of the basic_node class with a key of a compatible type with basic_node.
    /// @tparam KeyType A key type compatible with basic_node
    /// @param key A key to the target value in a sequence/mapping node.
    /// @return The value associated with the given key, or a default basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator[]/
    template <
        typename KeyType, detail::enable_if_t<
                              detail::conjunction<
                                  detail::negation<detail::is_basic_node<KeyType>>,
                                  detail::is_node_compatible_type<basic_node, KeyType>>::value,
                              int> = 0>
    basic_node& operator[](KeyType&& key) {
        basic_node& act_node = resolve_reference();

        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("operator[] is unavailable for a scalar node.", get_type());
        }

        basic_node key_node = std::forward<KeyType>(key);

        if (act_node.is_sequence_impl()) {
            // Do not use is_integer_impl() since n may be an anchor or alias.
            if FK_YAML_UNLIKELY (!key_node.is_integer()) {
                throw fkyaml::type_error(
                    "An argument of operator[] for sequence nodes must be an integer.", get_type());
            }
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return act_node.m_value.p_seq->operator[](key_node.get_value<int>());
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        return act_node.m_value.p_map->operator[](std::move(key_node));
    }

    /// @brief A subscript operator of the basic_node class with a key of a compatible type with basic_node.
    /// @tparam KeyType A key type compatible with basic_node
    /// @param key A key to the target value in a sequence/mapping node.
    /// @return The value associated with the given key, or a default basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator[]/
    template <
        typename KeyType, detail::enable_if_t<
                              detail::conjunction<
                                  detail::negation<detail::is_basic_node<KeyType>>,
                                  detail::is_node_compatible_type<basic_node, KeyType>>::value,
                              int> = 0>
    const basic_node& operator[](KeyType&& key) const {
        const basic_node& act_node = resolve_reference();

        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("operator[] is unavailable for a scalar node.", get_type());
        }

        basic_node key_node = std::forward<KeyType>(key);

        if (act_node.is_sequence_impl()) {
            if FK_YAML_UNLIKELY (!key_node.is_integer_impl()) {
                throw fkyaml::type_error(
                    "An argument of operator[] for sequence nodes must be an integer.", get_type());
            }
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return act_node.m_value.p_seq->operator[](key_node.get_value<int>());
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        return act_node.m_value.p_map->operator[](std::move(key_node));
    }

    /// @brief A subscript operator of the basic_node class with a basic_node key object.
    /// @tparam KeyType A key type which is a kind of the basic_node template class.
    /// @param key A key to the target value in a sequence/mapping node.
    /// @return The value associated with the given key, or a default basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator[]/
    template <typename KeyType, detail::enable_if_t<detail::is_basic_node<KeyType>::value, int> = 0>
    basic_node& operator[](KeyType&& key) {
        if FK_YAML_UNLIKELY (is_scalar()) {
            throw fkyaml::type_error("operator[] is unavailable for a scalar node.", get_type());
        }

        const node_value& node_value = resolve_reference().m_value;

        if (is_sequence()) {
            if FK_YAML_UNLIKELY (!key.is_integer()) {
                throw fkyaml::type_error(
                    "An argument of operator[] for sequence nodes must be an integer.", get_type());
            }
            FK_YAML_ASSERT(node_value.p_seq != nullptr);
            return node_value.p_seq->operator[](std::forward<KeyType>(key).template get_value<int>());
        }

        FK_YAML_ASSERT(node_value.p_map != nullptr);
        return node_value.p_map->operator[](std::forward<KeyType>(key));
    }

    /// @brief A subscript operator of the basic_node class with a basic_node key object.
    /// @tparam KeyType A key type which is a kind of the basic_node template class.
    /// @param key A key to the target value in a sequence/mapping node.
    /// @return The value associated with the given key, or a default basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator[]/
    template <typename KeyType, detail::enable_if_t<detail::is_basic_node<KeyType>::value, int> = 0>
    const basic_node& operator[](KeyType&& key) const {
        if FK_YAML_UNLIKELY (is_scalar()) {
            throw fkyaml::type_error("operator[] is unavailable for a scalar node.", get_type());
        }

        const node_value& node_value = resolve_reference().m_value;

        if (is_sequence()) {
            if FK_YAML_UNLIKELY (!key.is_integer()) {
                throw fkyaml::type_error(
                    "An argument of operator[] for sequence nodes must be an integer.", get_type());
            }
            FK_YAML_ASSERT(node_value.p_seq != nullptr);
            return node_value.p_seq->operator[](key.template get_value<int>());
        }

        FK_YAML_ASSERT(node_value.p_map != nullptr);
        return node_value.p_map->operator[](std::forward<KeyType>(key));
    }

    /// @brief An equal-to operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true if both types and values are equal, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_eq/
    bool operator==(const basic_node& rhs) const noexcept {
        const basic_node& lhs = resolve_reference();
        const basic_node& act_rhs = rhs.resolve_reference();

        const detail::node_attr_t lhs_val_bit = lhs.m_attrs & detail::node_attr_mask::value;
        if (lhs_val_bit != (act_rhs.m_attrs & detail::node_attr_mask::value)) {
            return false;
        }

        bool ret = false;
        switch (lhs_val_bit) {
        case detail::node_attr_bits::seq_bit:
            ret = (*(lhs.m_value.p_seq) == *(act_rhs.m_value.p_seq));
            break;
        case detail::node_attr_bits::map_bit:
            ret = (*(lhs.m_value.p_map) == *(act_rhs.m_value.p_map));
            break;
        case detail::node_attr_bits::null_bit:
            // Always true for comparisons between null nodes.
            ret = true;
            break;
        case detail::node_attr_bits::bool_bit:
            ret = (lhs.m_value.boolean == act_rhs.m_value.boolean);
            break;
        case detail::node_attr_bits::int_bit:
            ret = (lhs.m_value.integer == act_rhs.m_value.integer);
            break;
        case detail::node_attr_bits::float_bit:
            ret =
                (std::abs(lhs.m_value.float_val - act_rhs.m_value.float_val) <
                 std::numeric_limits<float_number_type>::epsilon());
            break;
        case detail::node_attr_bits::string_bit:
            ret = (*(lhs.m_value.p_str) == *(act_rhs.m_value.p_str));
            break;
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }

        return ret;
    }

    /// @brief A not-equal-to operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true if either types or values are different, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_ne/
    bool operator!=(const basic_node& rhs) const noexcept {
        return !operator==(rhs);
    }

    /// @brief A less-than operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true this basic_node object is less than `rhs`.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_lt/
    bool operator<(const basic_node& rhs) const noexcept {
        if (operator==(rhs)) {
            return false;
        }

        const basic_node& lhs = resolve_reference();
        const basic_node& act_rhs = rhs.resolve_reference();

        const detail::node_attr_t lhs_val_bit = lhs.m_attrs & detail::node_attr_mask::value;
        const detail::node_attr_t rhs_val_bit = act_rhs.m_attrs & detail::node_attr_mask::value;

        if (lhs_val_bit < rhs_val_bit) {
            return true;
        }

        if (lhs_val_bit != rhs_val_bit) {
            return false;
        }

        bool ret = false;
        switch (lhs_val_bit) {
        case detail::node_attr_bits::seq_bit:
            ret = (*(lhs.m_value.p_seq) < *(act_rhs.m_value.p_seq));
            break;
        case detail::node_attr_bits::map_bit:
            ret = (*(lhs.m_value.p_map) < *(act_rhs.m_value.p_map));
            break;
        case detail::node_attr_bits::null_bit: // LCOV_EXCL_LINE
            // Will not come here since null nodes are always the same.
            detail::unreachable(); // LCOV_EXCL_LINE
        case detail::node_attr_bits::bool_bit:
            // false < true
            ret = (!lhs.m_value.boolean && act_rhs.m_value.boolean);
            break;
        case detail::node_attr_bits::int_bit:
            ret = (lhs.m_value.integer < act_rhs.m_value.integer);
            break;
        case detail::node_attr_bits::float_bit:
            ret = (lhs.m_value.float_val < act_rhs.m_value.float_val);
            break;
        case detail::node_attr_bits::string_bit:
            ret = (*(lhs.m_value.p_str) < *(act_rhs.m_value.p_str));
            break;
        default:                   // LCOV_EXCL_LINE
            detail::unreachable(); // LCOV_EXCL_LINE
        }

        return ret;
    }

    /// @brief A less-than-or-equal-to operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true this basic_node object is less than or equal to `rhs`.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_le/
    bool operator<=(const basic_node& rhs) const noexcept {
        return !rhs.operator<(*this);
    }

    /// @brief A greater-than operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true this basic_node object is greater than `rhs`.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_gt/
    bool operator>(const basic_node& rhs) const noexcept {
        return !operator<=(rhs);
    }

    /// @brief A greater-than-or-equal-to operator of the basic_node class.
    /// @param rhs A basic_node object to be compared with this basic_node object.
    /// @return true this basic_node object is greater than or equal to `rhs`.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/operator_ge/
    bool operator>=(const basic_node& rhs) const noexcept {
        return !operator<(rhs);
    }

public:
    /// @brief Returns the type of the current basic_node value.
    /// @return The type of the YAML node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_type/
    node_type get_type() const noexcept {
        return detail::node_attr_bits::to_node_type(resolve_reference().m_attrs);
    }

    /// @brief Returns the type of the current basic_node value.
    /// @deprecated Use get_type() function. (since 0.3.12)
    /// @return The type of the YAML node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/type/
    FK_YAML_DEPRECATED("Since 0.3.12; Use get_type()")
    node_t type() const noexcept {
        node_type tmp_type = get_type();
        return detail::convert_from_node_type(tmp_type);
    }

    /// @brief Tests whether the current basic_node value is of sequence type.
    /// @return true if the type is sequence, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_sequence/
    bool is_sequence() const noexcept {
        return resolve_reference().is_sequence_impl();
    }

    /// @brief Tests whether the current basic_node value is of mapping type.
    /// @return true if the type is mapping, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_mapping/
    bool is_mapping() const noexcept {
        return resolve_reference().is_mapping_impl();
    }

    /// @brief Tests whether the current basic_node value is of null type.
    /// @return true if the type is null, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_null/
    bool is_null() const noexcept {
        return resolve_reference().is_null_impl();
    }

    /// @brief Tests whether the current basic_node value is of boolean type.
    /// @return true if the type is boolean, false otherwise
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_boolean/
    bool is_boolean() const noexcept {
        return resolve_reference().is_boolean_impl();
    }

    /// @brief Tests whether the current basic_node value is of integer type.
    /// @return true if the type is integer, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_integer/
    bool is_integer() const noexcept {
        return resolve_reference().is_integer_impl();
    }

    /// @brief Tests whether the current basic_node value is of float number type.
    /// @return true if the type is floating point number, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_float_number/
    bool is_float_number() const noexcept {
        return resolve_reference().is_float_number_impl();
    }

    /// @brief Tests whether the current basic_node value is of string type.
    /// @return true if the type is string, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_string/
    bool is_string() const noexcept {
        return resolve_reference().is_string_impl();
    }

    /// @brief Tests whether the current basic_node value is of scalar types.
    /// @return true if the type is scalar, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_scalar/
    bool is_scalar() const noexcept {
        return resolve_reference().is_scalar_impl();
    }

    /// @brief Tests whether the current basic_node is an anchor node.
    /// @return true if the current basic_node is an anchor node, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_anchor/
    bool is_anchor() const noexcept {
        return m_attrs & detail::node_attr_bits::anchor_bit;
    }

    /// @brief Tests whether the current basic_node is an alias node.
    /// @return true if the current basic_node is an alias node, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/is_alias/
    bool is_alias() const noexcept {
        return m_attrs & detail::node_attr_bits::alias_bit;
    }

    /// @brief Tests whether the current basic_node value (sequence, mapping, string) is empty.
    /// @return true if the node value is empty, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/empty/
    bool empty() const {
        const basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit: {
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return act_node.m_value.p_seq->empty();
        }
        case detail::node_attr_bits::map_bit: {
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return act_node.m_value.p_map->empty();
        }
        case detail::node_attr_bits::string_bit: {
            FK_YAML_ASSERT(act_node.m_value.p_str != nullptr);
            return act_node.m_value.p_str->empty();
        }
        default:
            throw fkyaml::type_error("The target node is not of a container type.", get_type());
        }
    }

    /// @brief Returns the size of the current basic_node value (sequence, mapping, string).
    /// @return The size of a node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/size/
    std::size_t size() const {
        const basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit:
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return act_node.m_value.p_seq->size();
        case detail::node_attr_bits::map_bit:
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return act_node.m_value.p_map->size();
        case detail::node_attr_bits::string_bit:
            FK_YAML_ASSERT(act_node.m_value.p_str != nullptr);
            return act_node.m_value.p_str->size();
        default:
            throw fkyaml::type_error("The target node is not of a container type.", get_type());
        }
    }

    /// @brief Check whether this basic_node object has a given key in its inner mapping node value.
    /// @tparam KeyType A key type compatible with basic_node.
    /// @param key A key to the target value in the mapping node value.
    /// @return true if the target node is a mapping and has the given key, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/contains/
    template <
        typename KeyType, detail::enable_if_t<
                              detail::disjunction<
                                  detail::is_basic_node<KeyType>,
                                  detail::is_node_compatible_type<basic_node, detail::remove_cvref_t<KeyType>>>::value,
                              int> = 0>
    bool contains(KeyType&& key) const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.m_attrs & detail::node_attr_bits::map_bit) {
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            const auto& map = *act_node.m_value.p_map;
            return map.find(std::forward<KeyType>(key)) != map.end();
        }

        return false;
    }

    /// @brief Get a basic_node object with a key of a compatible type.
    /// @tparam KeyType A key type compatible with basic_node
    /// @param key A key to the target basic_node object in a sequence/mapping node.
    /// @return Reference to the basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/at/
    template <
        typename KeyType, detail::enable_if_t<
                              detail::conjunction<
                                  detail::negation<detail::is_basic_node<KeyType>>,
                                  detail::is_node_compatible_type<basic_node, KeyType>>::value,
                              int> = 0>
    basic_node& at(KeyType&& key) {
        basic_node& act_node = resolve_reference();

        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("at() is unavailable for a scalar node.", get_type());
        }

        basic_node node_key = std::forward<KeyType>(key);

        if (act_node.is_sequence_impl()) {
            if FK_YAML_UNLIKELY (!node_key.is_integer_impl()) {
                throw fkyaml::type_error("An argument of at() for sequence nodes must be an integer.", get_type());
            }

            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            sequence_type& seq = *act_node.m_value.p_seq;
            int index = std::move(node_key).template get_value<int>();
            int size = static_cast<int>(seq.size());
            if FK_YAML_UNLIKELY (index >= size) {
                throw fkyaml::out_of_range(index);
            }
            return seq[index];
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        mapping_type& map = *act_node.m_value.p_map;
        const bool is_found = map.find(node_key) != map.end();
        if FK_YAML_UNLIKELY (!is_found) {
            throw fkyaml::out_of_range(serialize(node_key).c_str());
        }
        return map[std::move(node_key)];
    }

    /// @brief Get a basic_node object with a key of a compatible type.
    /// @tparam KeyType A key type compatible with basic_node
    /// @param key A key to the target basic_node object in a sequence/mapping node.
    /// @return Constant reference to the basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/at/
    template <
        typename KeyType, detail::enable_if_t<
                              detail::conjunction<
                                  detail::negation<detail::is_basic_node<KeyType>>,
                                  detail::is_node_compatible_type<basic_node, KeyType>>::value,
                              int> = 0>
    const basic_node& at(KeyType&& key) const {
        const basic_node& act_node = resolve_reference();

        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("at() is unavailable for a scalar node.", get_type());
        }

        basic_node node_key = std::forward<KeyType>(key);

        if (act_node.is_sequence_impl()) {
            if FK_YAML_UNLIKELY (!node_key.is_integer()) {
                throw fkyaml::type_error("An argument of at() for sequence nodes must be an integer.", get_type());
            }

            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            const sequence_type& seq = *act_node.m_value.p_seq;
            int index = std::move(node_key).template get_value<int>();
            int size = static_cast<int>(seq.size());
            if FK_YAML_UNLIKELY (index >= size) {
                throw fkyaml::out_of_range(index);
            }
            return seq[index];
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        const mapping_type& map = *act_node.m_value.p_map;
        const bool is_found = map.find(node_key) != map.end();
        if FK_YAML_UNLIKELY (!is_found) {
            throw fkyaml::out_of_range(serialize(node_key).c_str());
        }
        return map.at(std::move(node_key));
    }

    /// @brief Get a basic_node object with a basic_node key object.
    /// @tparam KeyType A key type which is a kind of the basic_node template class.
    /// @param key A key to the target basic_node object in a sequence/mapping node.
    /// @return Reference to the basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/at/
    template <typename KeyType, detail::enable_if_t<detail::is_basic_node<KeyType>::value, int> = 0>
    basic_node& at(KeyType&& key) {
        basic_node& act_node = resolve_reference();
        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("at() is unavailable for a scalar node.", get_type());
        }

        if (act_node.is_sequence_impl()) {
            if FK_YAML_UNLIKELY (!key.is_integer()) {
                throw fkyaml::type_error("An argument of at() for sequence nodes must be an integer.", get_type());
            }

            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            sequence_type& seq = *act_node.m_value.p_seq;
            int index = std::forward<KeyType>(key).template get_value<int>();
            int size = static_cast<int>(seq.size());
            if FK_YAML_UNLIKELY (index >= size) {
                throw fkyaml::out_of_range(index);
            }
            return seq[index];
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        mapping_type& map = *act_node.m_value.p_map;
        bool is_found = map.find(key) != map.end();
        if FK_YAML_UNLIKELY (!is_found) {
            throw fkyaml::out_of_range(serialize(key).c_str());
        }
        return map[std::forward<KeyType>(key)];
    }

    /// @brief Get a basic_node object with a basic_node key object.
    /// @tparam KeyType A key type which is a kind of the basic_node template class.
    /// @param key A key to the target basic_node object in a sequence/mapping node.
    /// @return Constant reference to the basic_node object associated with the given key.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/at/
    template <typename KeyType, detail::enable_if_t<detail::is_basic_node<KeyType>::value, int> = 0>
    const basic_node& at(KeyType&& key) const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_UNLIKELY (act_node.is_scalar_impl()) {
            throw fkyaml::type_error("at() is unavailable for a scalar node.", get_type());
        }

        if (act_node.is_sequence_impl()) {
            if FK_YAML_UNLIKELY (!key.is_integer()) {
                throw fkyaml::type_error("An argument of at() for sequence nodes must be an integer.", get_type());
            }

            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            const sequence_type& seq = *act_node.m_value.p_seq;
            int index = std::forward<KeyType>(key).template get_value<int>();
            int size = static_cast<int>(seq.size());
            if FK_YAML_UNLIKELY (index >= size) {
                throw fkyaml::out_of_range(index);
            }
            return seq[index];
        }

        FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
        const mapping_type& map = *act_node.m_value.p_map;
        bool is_found = map.find(key) != map.end();
        if FK_YAML_UNLIKELY (!is_found) {
            throw fkyaml::out_of_range(serialize(key).c_str());
        }
        return map.at(std::forward<KeyType>(key));
    }

    /// @brief Get the YAML version for this basic_node object.
    /// @return The YAML version if already set, `yaml_version_type::VERSION_1_2` otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_yaml_version_type/
    yaml_version_type get_yaml_version_type() const noexcept {
        return mp_meta->is_version_specified ? mp_meta->version : yaml_version_type::VERSION_1_2;
    }

    /// @brief Set the YAML version for this basic_node object.
    /// @param[in] version The target YAML version.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/set_yaml_version_type/
    void set_yaml_version_type(const yaml_version_type version) noexcept {
        mp_meta->version = version;
        mp_meta->is_version_specified = true;
    }

    /// @brief Get the YAML version for this basic_node object.
    /// @deprecated Use get_yaml_version_type() function. (since 0.3.12)
    /// @return The YAML version if already set, `yaml_version_t::VER_1_2` otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_yaml_version/
    FK_YAML_DEPRECATED("Since 0.3.12; Use get_yaml_version_type()")
    yaml_version_t get_yaml_version() const noexcept {
        yaml_version_type tmp_type = get_yaml_version_type();
        return detail::convert_from_yaml_version_type(tmp_type);
    }

    /// @brief Set the YAML version for this basic_node object.
    /// @deprecated Use set_yaml_version_type(yaml_version_type) function. (since 0.3.12)
    /// @param[in] version The target YAML version.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/set_yaml_version/
    FK_YAML_DEPRECATED("Since 0.3.12; Use set_yaml_version_type(const yaml_version_type)")
    void set_yaml_version(const yaml_version_t version) noexcept {
        set_yaml_version_type(detail::convert_to_yaml_version_type(version));
    }

    /// @brief Check whether this basic_node object has already had any anchor name.
    /// @return true if ths basic_node has an anchor name, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/has_anchor_name/
    bool has_anchor_name() const noexcept {
        return (m_attrs & detail::node_attr_mask::anchoring) && !m_prop.anchor.empty();
    }

    /// @brief Get the anchor name associated with this basic_node object.
    /// @note Some anchor name must be set before calling this method. Call has_anchor_name() to see if this basic_node
    /// object has any anchor name.
    /// @return The anchor name associated with the node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_anchor_name/
    const std::string& get_anchor_name() const {
        if FK_YAML_UNLIKELY (!has_anchor_name()) {
            throw fkyaml::exception("No anchor name has been set.");
        }
        return m_prop.anchor;
    }

    /// @brief Add an anchor name to this basic_node object.
    /// @note If this basic_node object has already had any anchor name, the new anchor name will overwrite the old one.
    /// @param[in] anchor_name An anchor name. This should not be empty.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/add_anchor_name/
    void add_anchor_name(const std::string& anchor_name) {
        if (is_anchor()) {
            m_attrs &= ~detail::node_attr_mask::anchoring;
            auto itr = mp_meta->anchor_table.equal_range(m_prop.anchor).first;
            std::advance(itr, detail::node_attr_bits::get_anchor_offset(m_attrs));
            mp_meta.reset();
            itr->second.swap(*this);
            mp_meta->anchor_table.erase(itr);
        }

        auto p_meta = mp_meta;

        basic_node node;
        node.swap(*this);
        p_meta->anchor_table.emplace(anchor_name, std::move(node));

        m_attrs &= ~detail::node_attr_mask::anchoring;
        m_attrs |= detail::node_attr_bits::anchor_bit;
        mp_meta = p_meta;
        const auto offset = static_cast<uint32_t>(mp_meta->anchor_table.count(anchor_name) - 1);
        detail::node_attr_bits::set_anchor_offset(offset, m_attrs);
        m_prop.anchor = anchor_name;
    }

    /// @brief Add an anchor name to this basic_node object.
    /// @note If this basic_node object has already had any anchor name, the new anchor name will overwrite the old one.
    /// @param[in] anchor_name An anchor name. This should not be empty.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/add_anchor_name/
    void add_anchor_name(std::string&& anchor_name) {
        if (is_anchor()) {
            m_attrs &= ~detail::node_attr_mask::anchoring;
            auto itr = mp_meta->anchor_table.equal_range(m_prop.anchor).first;
            std::advance(itr, detail::node_attr_bits::get_anchor_offset(m_attrs));
            mp_meta.reset();
            itr->second.swap(*this);
            mp_meta->anchor_table.erase(itr);
        }

        auto p_meta = mp_meta;

        basic_node node;
        node.swap(*this);
        p_meta->anchor_table.emplace(anchor_name, std::move(node));

        m_attrs &= ~detail::node_attr_mask::anchoring;
        m_attrs |= detail::node_attr_bits::anchor_bit;
        mp_meta = p_meta;
        auto offset = static_cast<uint32_t>(mp_meta->anchor_table.count(anchor_name) - 1);
        detail::node_attr_bits::set_anchor_offset(offset, m_attrs);
        m_prop.anchor = std::move(anchor_name);
    }

    /// @brief Check whether this basic_node object has already had any tag name.
    /// @return true if ths basic_node has a tag name, false otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/has_tag_name/
    bool has_tag_name() const noexcept {
        return !m_prop.tag.empty();
    }

    /// @brief Get the tag name associated with this basic_node object.
    /// @note Some tag name must be set before calling this method. Call has_tag_name() to see if this basic_node
    /// object has any tag name.
    /// @return The tag name associated with the node. It may be empty.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_tag_name/
    const std::string& get_tag_name() const {
        if FK_YAML_UNLIKELY (!has_tag_name()) {
            throw fkyaml::exception("No tag name has been set.");
        }
        return m_prop.tag;
    }

    /// @brief Add a tag name to this basic_node object.
    /// @note If this basic_node object has already had any tag name, the new tag name will overwrite the old one.
    /// @param[in] tag_name A tag name to get associated with this basic_node object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/add_tag_name/
    void add_tag_name(const std::string& tag_name) {
        m_prop.tag = tag_name;
    }

    /// @brief Add a tag name to this basic_node object.
    /// @note If this basic_node object has already had any tag name, the new tag name will overwrite the old one.
    /// @param[in] tag_name A tag name to get associated with this basic_node object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/add_tag_name/
    void add_tag_name(std::string&& tag_name) {
        m_prop.tag = std::move(tag_name);
    }

    /// @brief Get the node value object converted into a given type.
    /// @note This function requires T objects to be default constructible. Also, T cannot be either a reference,
    /// pointer or C-style array type.
    /// @tparam T A compatible value type which may be cv-qualified.
    /// @tparam ValueType A compatible value type (T without cv-qualifiers by default).
    /// @return A value converted from this basic_node object.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_value/
    template <
        typename T, typename ValueType = detail::remove_cv_t<T>,
        detail::enable_if_t<
            detail::conjunction<std::is_default_constructible<ValueType>, detail::negation<std::is_pointer<T>>>::value,
            int> = 0>
    T get_value() const noexcept(
        noexcept(std::declval<const basic_node&>().template get_value_impl<ValueType>(std::declval<ValueType&>()))) {
        // emit a compile error if T is either a reference, pointer or C-style array type.
        static_assert(
            !std::is_reference<T>::value,
            "get_value() cannot be called with reference types. "
            "You might want to call one of as_seq(), as_map(), as_bool(), as_int(), as_float() or as_str().");
        static_assert(
            !std::is_array<T>::value,
            "get_value() cannot be called with C-style array types. You might want to call get_value_inplace().");

        auto ret = ValueType();
        resolve_reference().get_value_impl(ret);
        return ret;
    }

    /// @brief Get the node value object converted into a given type. The conversion result is filled into `value_ref`.
    /// @tparam T A compatible value type.
    /// @param value_ref A storage into which the conversion result is filled.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_value_inplace/
    template <typename T>
    void get_value_inplace(T& value_ref) const
        noexcept(noexcept(std::declval<const basic_node&>().template get_value_impl<T>(std::declval<T&>()))) {
        resolve_reference().get_value_impl(value_ref);
    }

    /// @brief Get the node value object converted to a given type. If the conversion fails, this function returns a
    /// given default value instead.
    /// @note This function requires T to be default constructible. Also, T cannot be either a reference, pointer or
    /// C-style array type.
    /// @tparam T A compatible value type which may be cv-qualified.
    /// @tparam U A default value type from which T must be constructible.
    /// @param default_value The default value returned if conversion fails.
    /// @return A value converted from this basic_node object if conversion succeeded, the given default value
    /// otherwise.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_value_or/
    template <
        typename T, typename U,
        detail::enable_if_t<
            detail::conjunction<
                std::is_constructible<T, U>, std::is_default_constructible<T>,
                detail::negation<std::is_pointer<T>>>::value,
            int> = 0>
    T get_value_or(U&& default_value) const noexcept {
        static_assert(
            !std::is_reference<T>::value,
            "get_value_or() cannot be called with reference types. "
            "You might want to call one of as_seq(), as_map(), as_bool(), as_int(), as_float() or as_str().");
        static_assert(
            !std::is_array<T>::value,
            "get_value_or() cannot be called with C-style array types. You might want to call get_value_inplace().");

        // TODO:
        // Ideally, there should be no exception thrown in this kind of function. However, achieving that would require
        // a lot of refactoring and/or some API changes, especially `from_node` interface definition. So, try-catch is
        // used instead for now.
        try {
            return get_value<T>();
        }
        catch (const std::exception& /*unused*/) {
            // Any exception derived from std::exception is interpreted as a conversion failure in some way
            // since user-defined from_node function may throw a different object from a fkyaml::type_error.
            // and std::exception is usually the base class of user-defined exception types.
            return std::forward<U>(default_value);
        }
    }

    /// @brief Explicit reference access to the internally stored YAML node value.
    /// @tparam ReferenceType Reference type to the target YAML node value.
    /// @return Reference to the internally stored YAML node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_value_ref/
    template <typename ReferenceType, detail::enable_if_t<std::is_reference<ReferenceType>::value, int> = 0>
    FK_YAML_DEPRECATED("Since 0.4.3; Use one of as_seq(), as_map(), as_bool(), as_int(), as_float() or as_str()")
    ReferenceType get_value_ref() {
        return get_value_ref_impl(static_cast<detail::add_pointer_t<ReferenceType>>(nullptr));
    }

    /// @brief Explicit reference access to the internally stored YAML node value.
    /// @tparam ReferenceType Constant reference type to the target YAML node value.
    /// @return Constant reference to the internally stored YAML node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/get_value_ref/
    template <
        typename ReferenceType,
        detail::enable_if_t<
            detail::conjunction<
                std::is_reference<ReferenceType>, std::is_const<detail::remove_reference_t<ReferenceType>>>::value,
            int> = 0>
    FK_YAML_DEPRECATED("Since 0.4.3; Use one of as_seq(), as_map(), as_bool(), as_int(), as_float() or as_str()")
    ReferenceType get_value_ref() const {
        return get_value_ref_impl(static_cast<detail::add_pointer_t<ReferenceType>>(nullptr));
    }

    /// @brief Returns reference to the sequence node value.
    /// @throw fkyaml::type_error The node value is not a sequence.
    /// @return Reference to the sequence node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_seq/
    sequence_type& as_seq() {
        basic_node& act_node = resolve_reference(); // NOLINT(misc-const-correctness)
        if FK_YAML_LIKELY (act_node.is_sequence_impl()) {
            return *act_node.m_value.p_seq;
        }
        throw fkyaml::type_error("The node value is not a sequence.", get_type());
    }

    /// @brief Returns constant reference to the sequence node value.
    /// @throw fkyaml::type_error The node value is not a sequence.
    /// @return Constant reference to the sequence node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_seq/
    const sequence_type& as_seq() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_sequence_impl()) {
            return *act_node.m_value.p_seq;
        }
        throw fkyaml::type_error("The node value is not a sequence.", get_type());
    }

    /// @brief Returns reference to the mapping node value.
    /// @throw fkyaml::type_error The node value is not a mapping.
    /// @return Reference to the mapping node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_map/
    mapping_type& as_map() {
        basic_node& act_node = resolve_reference(); // NOLINT(misc-const-correctness)
        if FK_YAML_LIKELY (act_node.is_mapping_impl()) {
            return *act_node.m_value.p_map;
        }
        throw fkyaml::type_error("The node value is not a mapping.", get_type());
    }

    /// @brief Returns constant reference to the mapping node value.
    /// @throw fkyaml::type_error The node value is not a mapping.
    /// @return Constant reference to the mapping node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_map/
    const mapping_type& as_map() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_mapping_impl()) {
            return *act_node.m_value.p_map;
        }
        throw fkyaml::type_error("The node value is not a mapping.", get_type());
    }

    /// @brief Returns reference to the boolean node value.
    /// @throw fkyaml::type_error The node value is not a boolean.
    /// @return Reference to the boolean node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_bool/
    boolean_type& as_bool() {
        basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_boolean_impl()) {
            return act_node.m_value.boolean;
        }
        throw fkyaml::type_error("The node value is not a boolean.", get_type());
    }

    /// @brief Returns reference to the boolean node value.
    /// @throw fkyaml::type_error The node value is not a boolean.
    /// @return Constant reference to the boolean node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_bool/
    const boolean_type& as_bool() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_boolean_impl()) {
            return act_node.m_value.boolean;
        }
        throw fkyaml::type_error("The node value is not a boolean.", get_type());
    }

    /// @brief Returns reference to the integer node value.
    /// @throw fkyaml::type_error The node value is not an integer.
    /// @return Reference to the integer node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_int/
    integer_type& as_int() {
        basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_integer_impl()) {
            return act_node.m_value.integer;
        }
        throw fkyaml::type_error("The node value is not an integer.", get_type());
    }

    /// @brief Returns reference to the integer node value.
    /// @throw fkyaml::type_error The node value is not an integer.
    /// @return Constant reference to the integer node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_int/
    const integer_type& as_int() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_integer_impl()) {
            return act_node.m_value.integer;
        }
        throw fkyaml::type_error("The node value is not an integer.", get_type());
    }

    /// @brief Returns reference to the float node value.
    /// @throw fkyaml::type_error The node value is not a float.
    /// @return Reference to the float node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_float/
    float_number_type& as_float() {
        basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_float_number_impl()) {
            return act_node.m_value.float_val;
        }
        throw fkyaml::type_error("The node value is not a float.", get_type());
    }

    /// @brief Returns reference to the float node value.
    /// @throw fkyaml::type_error The node value is not a float.
    /// @return Constant reference to the float node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_float/
    const float_number_type& as_float() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_float_number_impl()) {
            return act_node.m_value.float_val;
        }
        throw fkyaml::type_error("The node value is not a float.", get_type());
    }

    /// @brief Returns reference to the string node value.
    /// @throw fkyaml::type_error The node value is not a string.
    /// @return Reference to the string node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_str/
    string_type& as_str() {
        basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_string_impl()) {
            return *act_node.m_value.p_str;
        }
        throw fkyaml::type_error("The node value is not a string.", get_type());
    }

    /// @brief Returns reference to the string node value.
    /// @throw fkyaml::type_error The node value is not a string.
    /// @return Constant reference to the string node value.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/as_str/
    const string_type& as_str() const {
        const basic_node& act_node = resolve_reference();
        if FK_YAML_LIKELY (act_node.is_string_impl()) {
            return *act_node.m_value.p_str;
        }
        throw fkyaml::type_error("The node value is not a string.", get_type());
    }

    /// @brief Swaps the internally stored data with the specified basic_node object.
    /// @param[in] rhs A basic_node object to be swapped with.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/swap/
    void swap(basic_node& rhs) noexcept {
        using std::swap;
        swap(m_attrs, rhs.m_attrs);
        swap(mp_meta, rhs.mp_meta);

        node_value tmp {};
        std::memcpy(&tmp, &m_value, sizeof(node_value));
        std::memcpy(&m_value, &rhs.m_value, sizeof(node_value));
        std::memcpy(&rhs.m_value, &tmp, sizeof(node_value));

        swap(m_prop.tag, rhs.m_prop.tag);
        swap(m_prop.anchor, rhs.m_prop.anchor);
    }

    /// @brief Returns an iterator to the first element of a container node (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return An iterator to the first element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/begin/
    iterator begin() {
        basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit:
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return {act_node.m_value.p_seq->begin()};
        case detail::node_attr_bits::map_bit:
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return {act_node.m_value.p_map->begin()};
        default:
            throw fkyaml::type_error("The target node is neither of sequence nor mapping types.", get_type());
        }
    }

    /// @brief Returns a const iterator to the first element of a container node (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the first element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/begin/
    const_iterator begin() const {
        const basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit:
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return {act_node.m_value.p_seq->begin()};
        case detail::node_attr_bits::map_bit:
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return {act_node.m_value.p_map->begin()};
        default:
            throw fkyaml::type_error("The target node is neither of sequence nor mapping types.", get_type());
        }
    }

    /// @brief Returns a const iterator to the first element of a container node (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the first element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/begin/
    const_iterator cbegin() const {
        return begin();
    }

    /// @brief Returns an iterator to the past-the-last element of a container node (sequence or mapping).
    /// @throw `type_error` if the basic_node value is not of container types.
    /// @return An iterator to the past-the-last element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/end/
    iterator end() {
        basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit:
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return {act_node.m_value.p_seq->end()};
        case detail::node_attr_bits::map_bit:
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return {act_node.m_value.p_map->end()};
        default:
            throw fkyaml::type_error("The target node is neither of sequence nor mapping types.", get_type());
        }
    }

    /// @brief Returns a const iterator to the past-the-last element of a container node (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the past-the-last element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/end/
    const_iterator end() const {
        const basic_node& act_node = resolve_reference();
        switch (act_node.m_attrs & detail::node_attr_mask::value) {
        case detail::node_attr_bits::seq_bit:
            FK_YAML_ASSERT(act_node.m_value.p_seq != nullptr);
            return {act_node.m_value.p_seq->end()};
        case detail::node_attr_bits::map_bit:
            FK_YAML_ASSERT(act_node.m_value.p_map != nullptr);
            return {act_node.m_value.p_map->end()};
        default:
            throw fkyaml::type_error("The target node is neither of sequence nor mapping types.", get_type());
        }
    }

    /// @brief Returns a const iterator to the past-the-last element of a container node (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the past-the-last element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/end/
    const_iterator cend() const {
        return end();
    }

    /// @brief Returns an iterator to the reverse-beginning (i.e., last) element of a container node (sequence or
    /// mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return An iterator to the reverse-beginning element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rbegin/
    reverse_iterator rbegin() {
        return {end()};
    }

    /// @brief Returns a const iterator to the reverse-beginning (i.e., last) element of a container node (sequence or
    /// mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the reverse-beginning element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rbegin/
    const_reverse_iterator rbegin() const {
        return {end()};
    }

    /// @brief Returns a const iterator to the reverse-beginning (i.e., last) element of a container node (sequence or
    /// mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the reverse-beginning element of a container node.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rbegin/
    const_reverse_iterator crbegin() const {
        return rbegin();
    }

    /// @brief Returns an iterator to the reverse-end (i.e., one before the first) element of a container node (sequence
    /// or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return An iterator to the reverse-end element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rend/
    reverse_iterator rend() {
        return {begin()};
    }

    /// @brief Returns a const iterator to the reverse-end (i.e., one before the first) element of a container node
    /// (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the reverse-end element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rend/
    const_reverse_iterator rend() const {
        return {begin()};
    }

    /// @brief Returns a const iterator to the reverse-end (i.e., one before the first) element of a container node
    /// (sequence or mapping).
    /// @throw `type_error` if this basic_node is neither a sequence nor mapping node.
    /// @return A const iterator to the reverse-end element.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/rend/
    const_reverse_iterator crend() const {
        return rend();
    }

    /// @brief Returns a range of mapping entries.
    /// @throw `type_error` if this basic_node is not a mapping.
    /// @return A range of mapping entries.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/map_items/
    map_range map_items() {
        if FK_YAML_UNLIKELY (!is_mapping()) {
            throw type_error("map_items() cannot be called on a non-mapping node.", get_type());
        }
        return {*this};
    }

    /// @brief Returns a const range of mapping entries.
    /// @throw `type_error` if this basic_node is not a mapping.
    /// @return A const range of mapping entries.
    /// @sa https://fktn-k.github.io/fkYAML/api/basic_node/map_items/
    const_map_range map_items() const {
        if FK_YAML_UNLIKELY (!is_mapping()) {
            throw type_error("map_items() cannot be called on a non-mapping node.", get_type());
        }
        return {*this};
    }

private:
    /// @brief Resolves anchor/alias reference and returns reference to an actual value node.
    /// @return Reference to an actual value node.
    basic_node& resolve_reference() {
        if FK_YAML_UNLIKELY (has_anchor_name()) {
            auto itr = mp_meta->anchor_table.equal_range(m_prop.anchor).first;
            std::advance(itr, detail::node_attr_bits::get_anchor_offset(m_attrs));
            return itr->second;
        }
        return *this;
    }

    /// @brief Resolves anchor/alias reference and returns const reference to an actual value node.
    /// @return Const reference to an actual value node.
    const basic_node& resolve_reference() const {
        if FK_YAML_UNLIKELY (has_anchor_name()) {
            auto itr = mp_meta->anchor_table.equal_range(m_prop.anchor).first;
            std::advance(itr, detail::node_attr_bits::get_anchor_offset(m_attrs));
            return itr->second;
        }
        return *this;
    }

    bool is_sequence_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::seq_bit;
    }

    bool is_mapping_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::map_bit;
    }

    bool is_null_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::null_bit;
    }

    bool is_boolean_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::bool_bit;
    }

    bool is_integer_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::int_bit;
    }

    bool is_float_number_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::float_bit;
    }

    bool is_string_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::string_bit;
    }

    bool is_scalar_impl() const noexcept {
        return m_attrs & detail::node_attr_bits::scalar_bits;
    }

    template <
        typename ValueType, detail::enable_if_t<detail::negation<detail::is_basic_node<ValueType>>::value, int> = 0>
    void get_value_impl(ValueType& v) const
        noexcept(noexcept(ConverterType<ValueType, void>::from_node(std::declval<const basic_node&>(), v))) {
        ConverterType<ValueType, void>::from_node(*this, v);
    }

    template <typename ValueType, detail::enable_if_t<detail::is_basic_node<ValueType>::value, int> = 0>
    void get_value_impl(ValueType& v) const {
        v = *this;
    }

    /// @brief Returns reference to the sequence node value.
    /// @throw fkyaml::exception The node value is not a sequence.
    /// @return Reference to the sequence node value.
    sequence_type& get_value_ref_impl(sequence_type* /*unused*/) {
        return as_seq();
    }

    /// @brief Returns constant reference to the sequence node value.
    /// @throw fkyaml::exception The node value is not a sequence.
    /// @return Constant reference to the sequence node value.
    const sequence_type& get_value_ref_impl(const sequence_type* /*unused*/) const {
        return as_seq();
    }

    /// @brief Returns reference to the mapping node value.
    /// @throw fkyaml::exception The node value is not a mapping.
    /// @return Reference to the mapping node value.
    mapping_type& get_value_ref_impl(mapping_type* /*unused*/) {
        return as_map();
    }

    /// @brief Returns constant reference to the mapping node value.
    /// @throw fkyaml::exception The node value is not a mapping.
    /// @return Constant reference to the mapping node value.
    const mapping_type& get_value_ref_impl(const mapping_type* /*unused*/) const {
        return as_map();
    }

    /// @brief Returns reference to the boolean node value.
    /// @throw fkyaml::exception The node value is not a boolean.
    /// @return Reference to the boolean node value.
    boolean_type& get_value_ref_impl(boolean_type* /*unused*/) {
        return as_bool();
    }

    /// @brief Returns reference to the boolean node value.
    /// @throw fkyaml::exception The node value is not a boolean.
    /// @return Constant reference to the boolean node value.
    const boolean_type& get_value_ref_impl(const boolean_type* /*unused*/) const {
        return as_bool();
    }

    /// @brief Returns reference to the integer node value.
    /// @throw fkyaml::exception The node value is not an integer.
    /// @return Reference to the integer node value.
    integer_type& get_value_ref_impl(integer_type* /*unused*/) {
        return as_int();
    }

    /// @brief Returns reference to the integer node value.
    /// @throw fkyaml::exception The node value is not an integer.
    /// @return Constant reference to the integer node value.
    const integer_type& get_value_ref_impl(const integer_type* /*unused*/) const {
        return as_int();
    }

    /// @brief Returns reference to the floating point number node value.
    /// @throw fkyaml::exception The node value is not a floating point number.
    /// @return Reference to the floating point number node value.
    float_number_type& get_value_ref_impl(float_number_type* /*unused*/) {
        return as_float();
    }

    /// @brief Returns reference to the floating point number node value.
    /// @throw fkyaml::exception The node value is not a floating point number.
    /// @return Constant reference to the floating point number node value.
    const float_number_type& get_value_ref_impl(const float_number_type* /*unused*/) const {
        return as_float();
    }

    /// @brief Returns reference to the string node value.
    /// @throw fkyaml::exception The node value is not a string.
    /// @return Reference to the string node value.
    string_type& get_value_ref_impl(string_type* /*unused*/) {
        return as_str();
    }

    /// @brief Returns reference to the string node value.
    /// @throw fkyaml::exception The node value is not a string.
    /// @return Constant reference to the string node value.
    const string_type& get_value_ref_impl(const string_type* /*unused*/) const {
        return as_str();
    }

    /// The current node attributes.
    detail::node_attr_t m_attrs {detail::node_attr_bits::default_bits};
    /// The shared set of YAML directives applied to this node.
    mutable std::shared_ptr<detail::document_metainfo<basic_node>> mp_meta {
        // NOLINTNEXTLINE(bugprone-unhandled-exception-at-new)
        std::shared_ptr<detail::document_metainfo<basic_node>>(new detail::document_metainfo<basic_node>())};
    /// The current node value.
    node_value m_value {};
    /// The property set of this node.
    detail::node_property m_prop {};
};

/// @brief Swap function for basic_node objects.
/// @param[in] lhs A left-side-hand basic_node object to be swapped with.
/// @param[in] rhs A right-side-hand basic_node object to be swapped with.
/// @sa https://fktn-k.github.io/fkYAML/api/swap/
template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename = void> class ConverterType>
inline void swap(
    basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>& lhs,
    basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>&
        rhs) noexcept(noexcept(lhs.swap(rhs))) {
    lhs.swap(rhs);
}

/// @brief Insertion operator for basic_node template class. A wrapper for the serialization feature.
/// @param[in] os An output stream object.
/// @param[in] n A basic_node object.
/// @return Reference to the output stream object `os`.
/// @sa https://fktn-k.github.io/fkYAML/api/basic_node/insertion_operator/
template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename = void> class ConverterType>
inline std::ostream& operator<<(
    std::ostream& os,
    const basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>&
        n) {
    os << basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>::
            serialize(n);
    return os;
}

/// @brief Extraction operator for basic_node template class. A wrapper for the deserialization feature with input
/// streams.
/// @param[in] is An input stream object.
/// @param[in] n A basic_node object.
/// @return Reference to the input stream object `is`.
/// @sa https://fktn-k.github.io/fkYAML/api/basic_node/extraction_operator/
template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename = void> class ConverterType>
inline std::istream& operator>>(
    std::istream& is,
    basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>& n) {
    n = basic_node<SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>::
        deserialize(is);
    return is;
}

/// @brief namespace for user-defined literals for the fkYAML library.
inline namespace literals {
/// @brief namespace for user-defined literals for YAML node objects.
inline namespace yaml_literals {

// Whitespace before the literal operator identifier is deprecated in C++23 or better but required in C++11.
// Ignore the warning as a workaround. https://github.com/fktn-k/fkYAML/pull/417
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated"
#endif

#if defined(__GNUC__) && (__GNUC__ > 6)
#define FK_YAML_QUOTE_OPERATOR operator""_yaml
#else
#define FK_YAML_QUOTE_OPERATOR operator"" _yaml
#endif

/// @brief The user-defined string literal which deserializes a `char` array into a `node` object.
/// @param s An input `char` array.
/// @param n The size of `s`.
/// @return The resulting `node` object deserialized from `s`.
/// @sa https://fktn-k.github.io/fkYAML/api/operator_literal_yaml/
inline fkyaml::node FK_YAML_QUOTE_OPERATOR(const char* s, std::size_t n) {
    return fkyaml::node::deserialize(s, s + n);
}

/// @brief The user-defined string literal which deserializes a `char16_t` array into a `node` object.
/// @param s An input `char16_t` array.
/// @param n The size of `s`.
/// @return The resulting `node` object deserialized from `s`.
/// @sa https://fktn-k.github.io/fkYAML/api/operator_literal_yaml/
inline fkyaml::node FK_YAML_QUOTE_OPERATOR(const char16_t* s, std::size_t n) {
    return fkyaml::node::deserialize(s, s + n);
}

/// @brief The user-defined string literal which deserializes a `char32_t` array into a `node` object.
/// @param s An input `char32_t` array.
/// @param n The size of `s`.
/// @return The resulting `node` object deserialized from `s`.
/// @sa https://fktn-k.github.io/fkYAML/api/operator_literal_yaml/
inline fkyaml::node FK_YAML_QUOTE_OPERATOR(const char32_t* s, std::size_t n) {
    return fkyaml::node::deserialize(s, s + n);
}

#if FK_YAML_HAS_CHAR8_T
/// @brief The user-defined string literal which deserializes a `char8_t` array into a `node` object.
/// @param s An input `char8_t` array.
/// @param n The size of `s`.
/// @return The resulting `node` object deserialized from `s`.
inline fkyaml::node FK_YAML_QUOTE_OPERATOR(const char8_t* s, std::size_t n) {
    return fkyaml::node::deserialize(s, s + n);
}

#if defined(__clang__)
#pragma clang diagnostic pop
#endif

#endif

} // namespace yaml_literals
} // namespace literals

FK_YAML_NAMESPACE_END

namespace std {

template <
    template <typename, typename...> class SequenceType, template <typename, typename, typename...> class MappingType,
    typename BooleanType, typename IntegerType, typename FloatNumberType, typename StringType,
    template <typename, typename = void> class ConverterType>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct hash<fkyaml::basic_node<
    SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>> {
    using node_t = fkyaml::basic_node<
        SequenceType, MappingType, BooleanType, IntegerType, FloatNumberType, StringType, ConverterType>;

    std::size_t operator()(const node_t& n) const {
        using boolean_type = typename node_t::boolean_type;
        using integer_type = typename node_t::integer_type;
        using float_number_type = typename node_t::float_number_type;
        using string_type = typename node_t::string_type;

        const auto type = n.get_type();

        std::size_t seed = 0;
        hash_combine(seed, std::hash<uint8_t>()(static_cast<uint8_t>(type)));

        switch (type) {
        case fkyaml::node_type::SEQUENCE:
            hash_combine(seed, n.size());
            for (const auto& elem : n) {
                hash_combine(seed, operator()(elem));
            }
            return seed;

        case fkyaml::node_type::MAPPING:
            hash_combine(seed, n.size());
            for (auto itr = n.begin(), end_itr = n.end(); itr != end_itr; ++itr) {
                hash_combine(seed, operator()(itr.key()));
                hash_combine(seed, operator()(itr.value()));
            }
            return seed;

        case fkyaml::node_type::NULL_OBJECT:
            hash_combine(seed, 0);
            return seed;
        case fkyaml::node_type::BOOLEAN:
            hash_combine(seed, std::hash<boolean_type>()(n.template get_value<boolean_type>()));
            return seed;
        case fkyaml::node_type::INTEGER:
            hash_combine(seed, std::hash<integer_type>()(n.template get_value<integer_type>()));
            return seed;
        case fkyaml::node_type::FLOAT:
            hash_combine(seed, std::hash<float_number_type>()(n.template get_value<float_number_type>()));
            return seed;
        case fkyaml::node_type::STRING:
            hash_combine(seed, std::hash<string_type>()(n.template get_value<string_type>()));
            return seed;
        default:                           // LCOV_EXCL_LINE
            fkyaml::detail::unreachable(); // LCOV_EXCL_LINE
        }
    }

private:
    // taken from boost::hash_combine
    FK_YAML_NO_SANITIZE("unsigned-shift-base", "unsigned-integer-overflow")
    static void hash_combine(std::size_t& seed, std::size_t v) {
        seed ^= v + 0x9e3779b9 + (seed << 6u) + (seed >> 2u);
    }
};

} // namespace std

#endif /* FK_YAML_NODE_HPP */