enum type can be case-insensitive-mapped with json?

[YunchengLiu]

NLOHMANN_JSON_SERIALIZE_ENUM provides a tool to map enum and json precisely. I want to know if it can provide a arg to specify enabling case-insensitive-mapping?

I think that most of the cases where enum is serialized to json should be ascii strings, so it should be more convenient to provide case-independent conversion in some scenarios, and there should be no need to consider UNICODE at this time.

#include <algorithm>
#include <string_view>

constexpr bool iequal(std::string_view lhs, std::string_view rhs) noexcept {
        return std::ranges::equal(lhs, rhs, [](char const c1, char const c2) noexcept{
                return std::tolower(c1) == std::tolower(c2);
            });
    }

#define NLOHMANN_JSON_CASE_INSENSITIVE_SERIALIZE_ENUM(EnumType, ...)            \
    template<typename JsonType>                                                 \
    inline void to_json(JsonType& j, EnumType const& e) {                       \
        static_assert(std::is_enum_v<EnumType>, #EnumType " must be an enum!"); \
        static std::pair<EnumType, JsonType> const m[] = __VA_ARGS__;           \
        auto it  = std::ranges::find_if(m, [e](auto const& obj) noexcept {      \
            return obj.first == e;                                              \
        });                                                                     \
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                 \
    }                                                                           \
    template<typename JsonType>                                                 \
    inline void from_json(JsonType const& j, EnumType& e) {                     \
        static_assert(std::is_enum_v<EnumType>, #EnumType " must be an enum!"); \
        static std::pair<EnumType, JsonType> const m[] = __VA_ARGS__;           \
        auto it  = std::ranges::find_if(m, [&j](auto const& obj) noexcept{      \
            return iequal(obj.second.dump(), j.dump());       /*modify here*/   \
        });                                                                     \
        e = ((it != std::end(m)) ? it : std::begin(m))->first;                  \
    }

I implemented it in this simple way (as above), and there seems to be no problem. Is there any other complicated situation that I have not considered?