//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.12.0
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT

#pragma once

#include <algorithm> // count, find, max, min
#include <array> // array
#include <cstddef> // size_t
#include <cstdint> // uint32_t
#include <cstring> // strlen
#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next, reverse_iterator
#include <limits> // numeric_limits
#include <memory> // unique_ptr
#include <streambuf> // streambuf
#include <string> // string, char_traits
#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
#include <utility> // declval, move, pair
#include <vector> // vector

#ifndef JSON_NO_IO
    #include <cstdio>   // FILE *
    #include <istream>  // istream
#endif                  // JSON_NO_IO

#include <nlohmann/detail/exceptions.hpp>
#include <nlohmann/detail/iterators/iterator_traits.hpp>
#include <nlohmann/detail/macro_scope.hpp>
#include <nlohmann/detail/meta/type_traits.hpp>
#include <nlohmann/detail/string_utils.hpp>

#ifndef JSON_NO_IO
    // Which unlocked stdio functions file_input_adapter uses (see
    // JSON_DISABLE_UNLOCKED_FILE_IO): 1 = POSIX flockfile/getc_unlocked,
    // 2 = Microsoft CRT _lock_file/_fgetc_nolock, 0 = none (std::fgetc, which
    // locks the file for every character). Only C libraries known to declare
    // the functions are listed; the macros are tested after <cstdio>, which
    // defines __GLIBC__. MemorySanitizer builds always use std::fgetc: glibc's
    // inline getc_unlocked reads the stdio buffer directly, which glibc (not
    // instrumented) filled, so MemorySanitizer would report a false positive.
    #if defined(__has_feature)
        #if __has_feature(memory_sanitizer)
            #define JSON_UNLOCKED_FILE_IO_MSAN 1
        #endif
    #endif

    #if JSON_DISABLE_UNLOCKED_FILE_IO || defined(JSON_UNLOCKED_FILE_IO_MSAN)
        #define JSON_UNLOCKED_FILE_IO 0
    #elif defined(_MSC_VER)
        #define JSON_UNLOCKED_FILE_IO 2
    #elif defined(__GLIBC__) || defined(__APPLE__) || defined(__ANDROID__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
        #define JSON_UNLOCKED_FILE_IO 1
    #else
        #define JSON_UNLOCKED_FILE_IO 0
    #endif
    #undef JSON_UNLOCKED_FILE_IO_MSAN

    // Whether file_input_adapter scans the buffer of the FILE directly, as
    // getc_unlocked() reads it: the fields it uses are those that the C
    // library's own getc_unlocked() macro uses (glibc: _IO_read_ptr and
    // _IO_read_end; Apple: _p and _r). It needs the file locked for the whole
    // parse, as JSON_UNLOCKED_FILE_IO == 1 has it (so JSON_DISABLE_UNLOCKED_FILE_IO
    // and MemorySanitizer builds turn it off).
    // (uClibc defines __GLIBC__ as well, but its FILE has other fields)
    #if JSON_UNLOCKED_FILE_IO == 1 && ((defined(__GLIBC__) && !defined(__UCLIBC__)) || defined(__APPLE__))
        #define JSON_FILE_WINDOW 1
    #else
        #define JSON_FILE_WINDOW 0
    #endif
#endif  // JSON_NO_IO

NLOHMANN_JSON_NAMESPACE_BEGIN
namespace detail
{

/// the supported input formats
enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata, bon8 };

/// @return the name of a binary input format, as used in exception messages
inline const char* input_format_name(const input_format_t format) noexcept
{
    switch (format)
    {
        case input_format_t::cbor:
            return "CBOR";
        case input_format_t::msgpack:
            return "MessagePack";
        case input_format_t::ubjson:
            return "UBJSON";
        case input_format_t::bson:
            return "BSON";
        case input_format_t::bjdata:
            return "BJData";
        case input_format_t::bon8:
            return "BON8";
        case input_format_t::json: // LCOV_EXCL_LINE
        default:            // LCOV_EXCL_LINE
            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
            return ""; // LCOV_EXCL_LINE
    }
}

/// @return the message of the parse_error thrown or reported for an empty input
inline const char* empty_input_message() noexcept
{
    return "attempting to parse an empty input; check that your input string or stream contains the expected JSON";
}

/*!
@brief the characters of the last read token, kept for error messages

A growable array of characters for the part of a token that an input adapter
copied out of its window, or that the lexer copies while it scans input it
cannot read again: unlike std::vector::push_back(), appending a character
takes no reference to a local, and is a few instructions when there is room.

The token is only needed for error messages, which show its first head()
characters and its last head() characters (see lexer::get_token_string). The
buffer therefore keeps the first head() and at least the last tail()
characters: when it is full and holds more than limit() characters, it drops
the characters in between instead of growing. That happens where it would
otherwise reallocate, so appending stays as cheap as before, and a long string
or a long run of whitespace read from a stream is not kept a second time.
*/
template<typename CharType>
class token_text_buffer
{
  public:
    static constexpr std::size_t head() noexcept
    {
        return 4096;
    }
    /// a little more than head(), as the last character may be handed back
    static constexpr std::size_t tail() noexcept
    {
        return head() + 16;
    }
    static constexpr std::size_t limit() noexcept
    {
        return head() + (2 * tail());
    }

    token_text_buffer() = default;
    token_text_buffer(const token_text_buffer&) = delete;
    token_text_buffer& operator=(const token_text_buffer&) = delete;
    token_text_buffer(token_text_buffer&& rhs) noexcept
        : m_data(std::move(rhs.m_data)), m_end(rhs.m_end), m_capacity_end(rhs.m_capacity_end)
    {
        rhs.m_end = rhs.m_capacity_end = nullptr;
    }
    token_text_buffer& operator=(token_text_buffer&& rhs) noexcept
    {
        m_data = std::move(rhs.m_data);
        m_end = rhs.m_end;
        m_capacity_end = rhs.m_capacity_end;
        rhs.m_end = rhs.m_capacity_end = nullptr;
        return *this;
    }
    ~token_text_buffer() = default;

    void clear() noexcept
    {
        m_end = m_data.get();
    }

    bool empty() const noexcept
    {
        return m_end == m_data.get();
    }

    void push_back(CharType c)
    {
        if (JSON_HEDLEY_UNLIKELY(m_end == m_capacity_end))
        {
            make_room(1);
        }
        *m_end++ = c;
    }

    /// drop the last character
    void pop_back() noexcept
    {
        JSON_ASSERT(!empty());
        --m_end;
    }

    void append(const CharType* first, const CharType* last)
    {
        const auto n = static_cast<std::size_t>(last - first);
        const auto room = static_cast<std::size_t>(m_capacity_end - m_end);
        if (JSON_HEDLEY_UNLIKELY(n > room))
        {
            append_long(first, n);
            return;
        }
        if (n != 0)
        {
            std::memcpy(m_end, first, n * sizeof(CharType));
        }
        m_end += n;
    }

    /// replace the contents of @a out
    void copy_to(std::vector<CharType>& out) const
    {
        out.assign(m_data.get(), m_end);
    }

  private:
    /// append @a n characters that do not fit, in pieces of at most tail()
    /// characters, so that dropping the middle keeps the last tail() of them
    JSON_HEDLEY_NEVER_INLINE void append_long(const CharType* first, std::size_t n)
    {
        while (n != 0)
        {
            const std::size_t piece = n < tail() ? n : tail();
            make_room(piece);
            std::memcpy(m_end, first, piece * sizeof(CharType));
            m_end += piece;
            first += piece;
            n -= piece;
        }
    }

    /// make room for @a extra (at most tail()) more characters: drop the
    /// middle of a long token instead of growing beyond limit()
    JSON_HEDLEY_NEVER_INLINE void make_room(std::size_t extra)
    {
        // nothing is allocated before the first character
        std::size_t size = m_data ? static_cast<std::size_t>(m_end - m_data.get()) : 0;
        if (size + extra > limit() && size > head() + tail())
        {
            std::memmove(m_data.get() + head(), m_end - tail(), tail() * sizeof(CharType));
            m_end = m_data.get() + head() + tail();
            size = head() + tail();
        }
        const std::size_t capacity = m_data ? static_cast<std::size_t>(m_capacity_end - m_data.get()) : 0;
        if (size + extra > capacity)
        {
            // never more than limit(): from there on, the middle is dropped
            const std::size_t doubled = capacity < 32 ? static_cast<std::size_t>(32) : 2 * capacity;
            const std::size_t new_capacity = (std::max)(doubled < limit() ? doubled : limit(), size + extra);
            std::unique_ptr<CharType[]> data(new CharType[new_capacity]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
            if (size != 0)
            {
                std::memcpy(data.get(), m_data.get(), size * sizeof(CharType));
            }
            m_data = std::move(data);
            m_end = m_data.get() + size;
            m_capacity_end = m_data.get() + new_capacity;
        }
    }

    std::unique_ptr<CharType[]> m_data{}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,readability-redundant-member-init)
    CharType* m_end = nullptr;
    CharType* m_capacity_end = nullptr;
};

/// the part of a token that an input adapter copied out of its window
using token_carry_buffer = token_text_buffer<char>;

////////////////////
// input adapters //
////////////////////

#ifndef JSON_NO_IO
/*!
Input adapter for stdio file access. The file is locked for the lifetime of the
adapter and read with the unlocked stdio functions (see
JSON_DISABLE_UNLOCKED_FILE_IO). With glibc and the Apple C library, the
characters in the buffer of the FILE are also scanned in bulk, as the get area
of a stream is (see input_stream_adapter): exactly the characters getc_unlocked()
would return are consumed, so the file is left where it was left before.
*/
class file_input_adapter
{
  public:
    using char_type = char;

    JSON_HEDLEY_NON_NULL(2)
    explicit file_input_adapter(std::FILE* f) noexcept
        : m_file(f)
    {
        JSON_ASSERT(m_file != nullptr);
        lock();
    }

    // make class move-only
    file_input_adapter(const file_input_adapter&) = delete;
    file_input_adapter(file_input_adapter&& rhs) noexcept
        : m_file(rhs.m_file)
#if JSON_FILE_WINDOW
        , token_carry(std::move(rhs.token_carry))
        , token_segment(rhs.token_segment)
        , current_in_buffer(rhs.current_in_buffer)
        , tracking_token(rhs.tracking_token)
#endif
    {
        // the lock is owned by the thread, not the adapter: hand it over
        rhs.m_file = nullptr;
    }
    file_input_adapter& operator=(const file_input_adapter&) = delete;
    file_input_adapter& operator=(file_input_adapter&&) = delete;
    ~file_input_adapter()
    {
        unlock();
    }

#if JSON_FILE_WINDOW
    std::char_traits<char>::int_type get_character()
    {
        // what getc_unlocked() does, while the buffer has characters
        const char* const next = buffer_ptr();
        if (JSON_HEDLEY_LIKELY(next != buffer_end()))
        {
            current_in_buffer = true;
            buffer_bump(1);
            return std::char_traits<char>::to_int_type(*next);
        }
        return get_character_slow();
    }
#else
    std::char_traits<char>::int_type get_character() noexcept
    {
        // the file is locked for the lifetime of the adapter, so the
        // per-character lock of std::fgetc can be skipped
#if JSON_UNLOCKED_FILE_IO == 1
        return getc_unlocked(m_file);
#elif JSON_UNLOCKED_FILE_IO == 2
        return _fgetc_nolock(m_file);
#else
        return std::fgetc(m_file);
#endif
    }
#endif

    // returns the number of characters successfully read
    template<class T>
    std::size_t get_elements(T* dest, std::size_t count = 1)
    {
        return fread(dest, 1, sizeof(T) * count, m_file);
    }

#if JSON_FILE_WINDOW
    // The lexer may scan the buffer of the FILE directly, as the window of
    // input_stream_adapter: the buffer ends wherever the C library's buffer
    // ends, and is refilled by the next get_character().
    static constexpr bool supports_bulk_scan = true;
    static constexpr bool bulk_window = true;

    // Pointer to the next unread character; only valid when bulk_remaining() > 0.
    const char* bulk_data() const
    {
        return buffer_ptr();
    }

    // Number of unread characters in the buffer.
    std::size_t bulk_remaining() const
    {
        if (!current_in_buffer)
        {
            return 0;
        }
        return static_cast<std::size_t>(buffer_end() - buffer_ptr());
    }

    // Consume @a n characters previously inspected via bulk_data().
    void bulk_skip(std::size_t n)
    {
        JSON_ASSERT(n <= bulk_remaining());
        buffer_bump(n);
    }

    // The adapter keeps the current token for the lexer's error messages, as
    // input_stream_adapter does.
    static constexpr bool supports_token_tracking = true;

    void begin_token() noexcept
    {
        tracking_token = true;
        token_carry.clear();
        token_segment = buffer_ptr();
    }

    void mark_token_start(std::char_traits<char>::int_type c)
    {
        tracking_token = true;
        token_carry.clear();
        if (current_in_buffer)
        {
            token_segment = buffer_ptr() - 1;
        }
        else
        {
            token_segment = nullptr;
            token_carry.push_back(std::char_traits<char>::to_char_type(c));
        }
    }

    void copy_token(std::vector<char>& out, bool drop_last) const
    {
        token_carry.copy_to(out);
        if (token_segment != nullptr)
        {
            out.insert(out.end(), token_segment, buffer_ptr());
        }
        if (drop_last && !out.empty())
        {
            out.pop_back();
        }
    }
#endif

  private:
#if JSON_FILE_WINDOW
    // the buffer of the FILE: [buffer_ptr(), buffer_end()) are the characters
    // getc_unlocked() would return next
#if defined(__GLIBC__)
    const char* buffer_ptr() const noexcept
    {
        return m_file->_IO_read_ptr;
    }
    const char* buffer_end() const noexcept
    {
        return m_file->_IO_read_end;
    }
    void buffer_bump(std::size_t n) noexcept
    {
        m_file->_IO_read_ptr += n;
    }
#else
    const char* buffer_ptr() const noexcept
    {
        return reinterpret_cast<const char*>(m_file->_p);
    }
    const char* buffer_end() const noexcept
    {
        return m_file->_r > 0 ? reinterpret_cast<const char*>(m_file->_p) + m_file->_r : reinterpret_cast<const char*>(m_file->_p);
    }
    void buffer_bump(std::size_t n) noexcept
    {
        m_file->_p += n;
        m_file->_r -= static_cast<int>(n);
    }
#endif

    // the buffer is exhausted: getc_unlocked() refills it
    JSON_HEDLEY_NEVER_INLINE std::char_traits<char>::int_type get_character_slow()
    {
        if (token_segment != nullptr)
        {
            token_carry.append(token_segment, buffer_end());
            token_segment = nullptr;
        }
        const auto res = getc_unlocked(m_file);
        if (res == EOF)
        {
            current_in_buffer = false;
            return std::char_traits<char>::eof();
        }
        // the character was taken from the refilled buffer, at buffer_ptr() - 1
        current_in_buffer = true;
        if (tracking_token)
        {
            token_segment = buffer_ptr() - 1;
        }
        return res;
    }

#endif

    // Lock the file once for the whole parse instead of once per character.
    // The lock is recursive, so fread() and the user's own stdio calls on the
    // same thread keep working.
    void lock() noexcept
    {
#if JSON_UNLOCKED_FILE_IO == 1
        flockfile(m_file);
#elif JSON_UNLOCKED_FILE_IO == 2
        _lock_file(m_file);
#endif
    }

    void unlock() noexcept
    {
        // a moved-from adapter has no file and holds no lock
        if (m_file == nullptr)
        {
            return;
        }
#if JSON_UNLOCKED_FILE_IO == 1
        funlockfile(m_file);
#elif JSON_UNLOCKED_FILE_IO == 2
        _unlock_file(m_file);
#endif
    }

    /// the file pointer to read from
    std::FILE* m_file;
#if JSON_FILE_WINDOW
    /// the part of the current token that was in earlier buffers
    token_carry_buffer token_carry{}; // NOLINT(readability-redundant-member-init)
    /// start of the current token's part in the buffer, or nullptr
    const char* token_segment = nullptr;
    /// whether the character last returned by get_character() is in the buffer
    bool current_in_buffer = false;
    /// whether a token is tracked at all; the binary readers never start one
    bool tracking_token = false;
#endif
};

/*!
Input adapter for a (caching) istream. Does not skip a UTF Byte Order Mark
itself; that is done by the lexer's skip_bom(). Does not support changing
the underlying std::streambuf
in mid-input. Maintains underlying std::istream and std::streambuf to support
subsequent use of standard std::istream operations to process any input
characters following those used in parsing the JSON input.  Clears the
std::istream flags; any input errors (e.g., EOF) will be detected by the first
subsequent call for input from the std::istream.
*/
class input_stream_adapter
{
  public:
    using char_type = char;

    ~input_stream_adapter()
    {
        // clear stream flags; we use underlying streambuf I/O, do not
        // maintain ifstream flags, except eof
        if (is != nullptr)
        {
#if JSON_PRECISE_STREAM_POSITION
            // consume the character last returned by get_character() unless it
            // was given back with release_lookahead()
            commit_lookahead();
#endif
            // only call clear() if there is something to clear: it throws
            // std::ios_base::failure if the stream has exceptions() enabled
            // for a state bit that remains set, and a destructor must not throw
            if ((is->rdstate() & ~std::ios::eofbit) != 0)
            {
                is->clear(is->rdstate() & std::ios::eofbit);
            }
        }
    }

    explicit input_stream_adapter(std::istream& i)
        : is(&i), sb(i.rdbuf())
    {}

    // deleted because of pointer members
    input_stream_adapter(const input_stream_adapter&) = delete;
    input_stream_adapter& operator=(input_stream_adapter&) = delete;
    input_stream_adapter& operator=(input_stream_adapter&&) = delete;

    input_stream_adapter(input_stream_adapter&& rhs) noexcept
        : is(rhs.is), sb(rhs.sb)
#if JSON_PRECISE_STREAM_POSITION
        , lookahead(rhs.lookahead)
#endif
#if !JSON_DISABLE_STREAM_BULK_SCAN
        , token_carry(std::move(rhs.token_carry))
        , token_segment(rhs.token_segment)
        , current_in_get_area(rhs.current_in_get_area)
        , tracking_token(rhs.tracking_token)
        , no_get_area(rhs.no_get_area)
#endif
    {
        rhs.is = nullptr;
        rhs.sb = nullptr;
#if JSON_PRECISE_STREAM_POSITION
        rhs.lookahead = false;
#endif
    }

#if JSON_PRECISE_STREAM_POSITION
    // Whether the character last returned by get_character() can be given back
    // to the input with release_lookahead().
    static constexpr bool supports_lookahead = true;

    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
    // end up as the same value, e.g., 0xFFFFFFFF.
    //
    // The character is peeked rather than consumed: it is only stepped over
    // once the next character is requested, or when the adapter is destroyed.
    // Until then, release_lookahead() can leave it in the input.
    std::char_traits<char>::int_type get_character()
    {
        if (lookahead)
        {
            // step over the character returned by the previous call
            sb->sbumpc();
        }

#if !JSON_DISABLE_STREAM_BULK_SCAN
        // sgetc() refills the get area if it is exhausted
        const bool refill = streambuf_access::get_ptr(sb) == streambuf_access::get_end(sb);
        if (JSON_HEDLEY_UNLIKELY(refill))
        {
            save_token_segment();
        }
#endif

        auto res = sb->sgetc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
            // there is nothing to step over next time
            lookahead = false;
#if !JSON_DISABLE_STREAM_BULK_SCAN
            current_in_get_area = false;
#endif
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        else
        {
            lookahead = true;
#if !JSON_DISABLE_STREAM_BULK_SCAN
            if (JSON_HEDLEY_UNLIKELY(refill))
            {
                // the peeked character is at gptr(), unless the streambuf has
                // no get area
                after_refill(res, streambuf_access::get_ptr(sb) != streambuf_access::get_end(sb));
            }
            else
            {
                current_in_get_area = true;
            }
#endif
        }
        return res;
    }

    // Leave the character last returned by get_character() in the input, so
    // that the next read from the stream - by this adapter or by the caller
    // once parsing is done - sees it again. Unlike putting a consumed
    // character back, this cannot fail.
    void release_lookahead() noexcept
    {
        lookahead = false;
    }
#else
    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
    // end up as the same value, e.g., 0xFFFFFFFF.
    //
    // The character is consumed, so the character that terminates a number
    // stays consumed after parsing; see JSON_PRECISE_STREAM_POSITION.
    std::char_traits<char>::int_type get_character()
    {
#if !JSON_DISABLE_STREAM_BULK_SCAN
        // the character is in the get area: step over it, as sbumpc() does
        const char* const next = streambuf_access::get_ptr(sb);
        if (JSON_HEDLEY_LIKELY(next != streambuf_access::get_end(sb)))
        {
            current_in_get_area = true;
            streambuf_access::bump(sb, 1);
            return std::char_traits<char>::to_int_type(*next);
        }
        if (no_get_area)
        {
            return get_character_no_get_area();
        }
#endif
        return get_character_slow();
    }
#endif

    template<class T>
    std::size_t get_elements(T* dest, std::size_t count = 1)
    {
#if JSON_PRECISE_STREAM_POSITION
        commit_lookahead();
#endif
#if !JSON_DISABLE_STREAM_BULK_SCAN
        // the elements are in the get area: copy them, as sgetn() does, but
        // without the virtual call
        const char* const first = streambuf_access::get_ptr(sb);
        const auto available = static_cast<std::size_t>(streambuf_access::get_end(sb) - first);
        if (JSON_HEDLEY_LIKELY(count * sizeof(T) <= available && count * sizeof(T) <= static_cast<std::size_t>((std::numeric_limits<int>::max)())))
        {
            std::memcpy(dest, first, count * sizeof(T));
            streambuf_access::bump(sb, static_cast<int>(count * sizeof(T)));
            return count * sizeof(T);
        }
#endif
        auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
        if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

#if !JSON_DISABLE_STREAM_BULK_SCAN
    // The lexer may scan the characters in the get area of the streambuf
    // directly (SWAR fast paths). The get area is only a window into the
    // input: it ends wherever the streambuf's buffer ends, and is refilled by
    // the next get_character(). The lexer therefore keeps counting the
    // position itself and treats the end of the window as "unknown", not as
    // the end of the input.
    static constexpr bool supports_bulk_scan = true;
    static constexpr bool bulk_window = true;

    // Pointer to the next unread character; only valid when
    // bulk_remaining() > 0. The character before it is the one last returned
    // by get_character().
    const char* bulk_data() const
    {
        return current_end();
    }

    // Number of unread characters in the get area.
    std::size_t bulk_remaining() const
    {
        if (!current_in_get_area)
        {
            return 0;
        }
        return static_cast<std::size_t>(streambuf_access::get_end(sb) - current_end());
    }

    // Consume @a n characters previously inspected via bulk_data(); the last
    // of them becomes the character last returned by get_character().
    void bulk_skip(std::size_t n)
    {
        JSON_ASSERT(n <= bulk_remaining());
        // gbump() takes an int, but a get area (e.g., of a std::stringbuf) can
        // be larger
        constexpr auto max_bump = static_cast<std::size_t>((std::numeric_limits<int>::max)());
        for (; n > max_bump; n -= max_bump)
        {
            streambuf_access::bump(sb, static_cast<int>(max_bump));
        }
        streambuf_access::bump(sb, static_cast<int>(n));
    }

    // The adapter keeps the current token for the lexer's error messages: the
    // part in the get area is only remembered as a pointer, and copied out
    // when the get area is about to be refilled.
    static constexpr bool supports_token_tracking = true;

    // Start a token with the characters read from now on. Until this is
    // called, nothing is tracked (the binary readers never call it).
    void begin_token() noexcept
    {
        tracking_token = true;
        token_carry.clear();
        token_segment = current_end();
    }

    // Start a new token with the character @a c last returned by
    // get_character().
    void mark_token_start(std::char_traits<char>::int_type c)
    {
        tracking_token = true;
        token_carry.clear();
        if (current_in_get_area)
        {
            token_segment = current_end() - 1;
        }
        else
        {
            token_segment = nullptr;
            token_carry.push_back(std::char_traits<char>::to_char_type(c));
        }
    }

    // Copy the characters read since mark_token_start() to @a out, without the
    // last one if @a drop_last.
    void copy_token(std::vector<char>& out, bool drop_last) const
    {
        token_carry.copy_to(out);
        if (token_segment != nullptr)
        {
            out.insert(out.end(), token_segment, current_end());
        }
        if (drop_last && !out.empty())
        {
            out.pop_back();
        }
    }
#endif

  private:
#if !JSON_PRECISE_STREAM_POSITION
    // the get area is exhausted, or there is none
#if !JSON_DISABLE_STREAM_BULK_SCAN
    JSON_HEDLEY_NEVER_INLINE
#endif
    std::char_traits<char>::int_type get_character_slow()
    {
#if !JSON_DISABLE_STREAM_BULK_SCAN
        // the get area is exhausted (get_character() handles the other case),
        // so sbumpc() refills it
        save_token_segment();
#endif

        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
#if !JSON_DISABLE_STREAM_BULK_SCAN
            current_in_get_area = false;
#endif
            is->clear(is->rdstate() | std::ios::eofbit);
        }
#if !JSON_DISABLE_STREAM_BULK_SCAN
        else
        {
            // the consumed character is at gptr() - 1, unless the streambuf
            // has no get area and returned it from uflow()
            const char* const next = streambuf_access::get_ptr(sb);
            after_refill(res, next != nullptr && next != streambuf_access::get_begin(sb));
        }
#endif
        return res;
    }
#endif
#if !JSON_DISABLE_STREAM_BULK_SCAN
    // Reads the protected get-area pointers of any std::streambuf. Naming the
    // members through a derived class makes forming the member pointers
    // accessible; calling them on another streambuf object is then ordinary
    // member access through a pointer to member.
    struct streambuf_access : std::streambuf
    {
        static const char* get_ptr(std::streambuf* s)
        {
            return (s->*(&streambuf_access::gptr))();
        }
        static const char* get_end(std::streambuf* s)
        {
            return (s->*(&streambuf_access::egptr))();
        }
        static const char* get_begin(std::streambuf* s)
        {
            return (s->*(&streambuf_access::eback))();
        }
        static void bump(std::streambuf* s, int n)
        {
            (s->*(&streambuf_access::gbump))(n);
        }
        // sbumpc() for an exhausted get area
        static std::streambuf::int_type next_character(std::streambuf* s)
        {
            return (s->*(&streambuf_access::uflow))();
        }
    };

    // one past the character last returned by get_character(), if that is in
    // the get area
    const char* current_end() const
    {
#if JSON_PRECISE_STREAM_POSITION
        // the character is peeked at gptr() and not stepped over yet, unless
        // it was given back with release_lookahead()
        return streambuf_access::get_ptr(sb) + (lookahead ? 1 : 0);
#else
        return streambuf_access::get_ptr(sb);
#endif
    }

    // the get area is about to be replaced: copy the token's part in it
    void save_token_segment()
    {
        if (token_segment != nullptr)
        {
            token_carry.append(token_segment, streambuf_access::get_end(sb));
            token_segment = nullptr;
        }
    }

#if !JSON_PRECISE_STREAM_POSITION
    // The streambuf has no get area (e.g., std::cin synchronized with stdio):
    // every character comes from uflow(), and the token is kept by value.
    JSON_HEDLEY_NEVER_INLINE std::char_traits<char>::int_type get_character_no_get_area()
    {
        // the get area is exhausted, so this is what sbumpc() does
        const auto res = streambuf_access::next_character(sb);
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof() || streambuf_access::get_end(sb) != nullptr))
        {
            return get_character_no_get_area_other(res);
        }
        // current_in_get_area is false: only the first character of a get
        // area, or the end of the input, is read here
        if (tracking_token)
        {
            token_carry.push_back(std::char_traits<char>::to_char_type(res));
        }
        return res;
    }

    // @a res came from uflow() of a streambuf without a get area: it is the
    // end of the input, or the streambuf has a get area now
    JSON_HEDLEY_NEVER_INLINE std::char_traits<char>::int_type get_character_no_get_area_other(std::char_traits<char>::int_type res)
    {
        if (res == std::char_traits<char>::eof())
        {
            current_in_get_area = false;
            is->clear(is->rdstate() | std::ios::eofbit);
            return res;
        }
        // the consumed character is at gptr() - 1
        after_refill(res, streambuf_access::get_ptr(sb) != streambuf_access::get_begin(sb));
        return res;
    }
#endif

    // character @a c was just read into a new get area (@a in_get_area) or
    // returned without one
    void after_refill(std::char_traits<char>::int_type c, bool in_get_area)
    {
        current_in_get_area = in_get_area;
        no_get_area = !in_get_area;
        if (!tracking_token)
        {
            return;
        }
        if (in_get_area)
        {
            token_segment = current_end() - 1;
        }
        else
        {
            token_carry.push_back(std::char_traits<char>::to_char_type(c));
        }
    }
#endif

#if JSON_PRECISE_STREAM_POSITION
    // Step over the character last returned by get_character(). The character
    // has already been peeked successfully, so for every streambuf with a get
    // area this is a pointer increment that cannot fail.
    void commit_lookahead()
    {
        if (lookahead)
        {
            lookahead = false;
            sb->sbumpc();
        }
    }
#endif

    /// the associated input stream
    std::istream* is = nullptr;
    std::streambuf* sb = nullptr;
#if JSON_PRECISE_STREAM_POSITION
    /// whether get_character() peeked a character that is not consumed yet
    bool lookahead = false;
#endif
#if !JSON_DISABLE_STREAM_BULK_SCAN
    /// the part of the current token that was in earlier get areas
    token_carry_buffer token_carry{}; // NOLINT(readability-redundant-member-init)
    /// start of the current token's part in the get area, or nullptr
    const char* token_segment = nullptr;
    /// whether the character last returned by get_character() is in the get area
    bool current_in_get_area = false;
    /// whether a token is tracked at all; the binary readers never start one
    bool tracking_token = false;
    /// whether the streambuf had no get area when it was last asked for a
    /// character
    bool no_get_area = false;
#endif
};
#endif  // JSON_NO_IO

// General-purpose iterator-based adapter. It might not be as fast as
// theoretically possible for some containers, but it is extremely versatile.
// SentinelType defaults to IteratorType for backward compatibility, but may be
// a different type, e.g. a C++20 sentinel such as std::default_sentinel_t when
// IteratorType is a std::counted_iterator.
template<typename IteratorType, typename SentinelType = IteratorType>
class iterator_input_adapter
{
    // Whether the number of elements between two positions can be computed in
    // O(1): either the iterator and the sentinel have the same type (plain
    // std::distance) or, in C++20, the sentinel is a sized sentinel for the
    // iterator (std::ranges::distance), e.g. std::default_sentinel_t paired
    // with std::counted_iterator.
    //
    // JSON_HAS_RANGES gates the C++20 branch: on standard libraries with an
    // incomplete <ranges> (libstdc++ < 11, see #4440) evaluating
    // std::contiguous_iterator on a std::counted_iterator is a hard error
    // instead of yielding false, and these traits are instantiated for every
    // adapter. Such toolchains fall back to the pointer-only test and simply
    // use the byte-at-a-time scanner.
    static constexpr bool sentinel_is_sized =
#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>;
#else
        std::is_same<IteratorType, SentinelType>::value;
#endif

  public:
    using char_type = typename std::iterator_traits<IteratorType>::value_type;

    // Whether the lexer may reconstruct already-consumed input on demand (for
    // diagnostics) instead of copying every scanned character eagerly. This is
    // only sound for multi-pass, randomly-addressable byte input: the iterator
    // must be random-access (so the consumed prefix can be revisited in O(1))
    // and each element must map 1:1 to an input byte (wide inputs are wrapped
    // in wide_string_input_adapter, which does not expose this).
    static constexpr bool supports_seek =
        std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
        && sentinel_is_sized
        && sizeof(char_type) == 1;

    iterator_input_adapter(IteratorType first, SentinelType last)
        : begin(first), current(std::move(first)), end(std::move(last))
    {}

    typename char_traits<char_type>::int_type get_character()
    {
        if (JSON_HEDLEY_LIKELY(current != end))
        {
            auto result = char_traits<char_type>::to_int_type(*current);
            std::advance(current, 1);
            return result;
        }

        ++eof_reads;
        return char_traits<char_type>::eof();
    }

    // number of characters consumed from the input so far
    std::size_t get_consumed_count() const
    {
        return static_cast<std::size_t>(std::distance(begin, current));
    }

    // number of get_character() calls so far, including those that returned
    // EOF; the lexer derives its position from it (see lexer::lazy_position)
    std::size_t get_read_count() const
    {
        return get_consumed_count() + eof_reads;
    }

    // number of newlines in the consumed range [0, last_index); @a line_start
    // is set to the index after the last of them (0 if there is none); only
    // valid when supports_seek
    std::size_t count_consumed_lines(std::size_t last_index, std::size_t& line_start) const
    {
        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
        const auto newline = char_traits<char_type>::to_char_type('\n');
        using reverse_it = std::reverse_iterator<IteratorType>;
        const auto last_newline = std::find(reverse_it(to), reverse_it(begin), newline);
        line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
        return static_cast<std::size_t>(std::count(begin, last_newline.base(), newline));
    }

    // append the already-consumed characters in the half-open range
    // [first_index, last_index) to @a out; only valid when supports_seek
    template<typename ContainerType>
    void copy_consumed_range(std::size_t first_index, std::size_t last_index, ContainerType& out) const
    {
        const auto from = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(first_index));
        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
        out.insert(out.end(), from, to);
    }

    // Copy up to count * sizeof(T) bytes into dest, returning the number of
    // bytes actually read. For contiguous iterators (e.g. pointers) this is a
    // single std::memcpy; for general iterators we fall back to processing the
    // range one-by-one.
    template<class T>
    std::size_t get_elements(T* dest, std::size_t count = 1)
    {
        return get_elements_impl(dest, count, std::integral_constant<bool, iterator_is_contiguous> {});
    }

  private:
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
    // library iterators such as those of std::vector and std::string). The
    // available element count must also be computable in O(1), hence
    // sentinel_is_sized.
    static constexpr bool iterator_is_contiguous = sentinel_is_sized &&
#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
#else
        std::is_pointer<IteratorType>::value;
#endif

    // number of unread elements in [current, end)
    std::size_t remaining_count() const
    {
#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        return static_cast<std::size_t>(std::ranges::distance(current, end));
#else
        return static_cast<std::size_t>(std::distance(current, end));
#endif
    }

  public:
    // Whether the remaining input is a single contiguous block of 1-byte
    // elements that the lexer can inspect directly (used for the SWAR string
    // fast path).
    static constexpr bool supports_bulk_scan =
        iterator_is_contiguous && sizeof(char_type) == 1;

    // Pointer to the next unread element; only valid when bulk_remaining() > 0.
    const char_type* bulk_data() const
    {
        return &*current;
    }

    // Number of unread elements available as one contiguous block.
    std::size_t bulk_remaining() const
    {
        return remaining_count();
    }

    // Consume @a n elements previously inspected via bulk_data().
    void bulk_skip(std::size_t n)
    {
        std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(n));
    }

  private:
    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
        const std::size_t available = remaining_count() * sizeof(char_type);
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
            // the copy must stay within both buffers: the caller-provided
            // destination holds `wanted` bytes and the remaining input range
            // holds `available` bytes, and `copied` is the minimum of the two
            JSON_ASSERT(copied <= wanted);    // does not overrun the destination
            JSON_ASSERT(copied <= available); // does not read past the input end
            // &*current yields the raw address for both raw pointers and
            // non-pointer contiguous iterators (e.g. std::vector's iterator)
            std::memcpy(dest, &*current, copied);
            std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(copied / sizeof(char_type)));
        }
        return copied;
    }

    // general fallback: copy the range one element at a time
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::false_type /*contiguous*/)
    {
        auto* ptr = reinterpret_cast<char*>(dest);
        for (std::size_t read_index = 0; read_index < count * sizeof(T); ++read_index)
        {
            if (JSON_HEDLEY_LIKELY(current != end))
            {
                ptr[read_index] = static_cast<char>(*current);
                std::advance(current, 1);
            }
            else
            {
                return read_index;
            }
        }
        return count * sizeof(T);
    }

    IteratorType begin;
    IteratorType current;
    SentinelType end;
    /// number of get_character() calls that returned EOF
    std::size_t eof_reads = 0;

    template<typename BaseInputAdapter, size_t T>
    friend struct wide_string_input_helper;

    bool empty() const
    {
        return current == end;
    }
};

template<typename BaseInputAdapter, size_t T>
struct wide_string_input_helper;

template<typename BaseInputAdapter>
struct wide_string_input_helper<BaseInputAdapter, 4>
{
    // UTF-32
    static void fill_buffer(BaseInputAdapter& input,
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
                            size_t& utf8_bytes_index,
                            size_t& utf8_bytes_filled)
    {
        utf8_bytes_index = 0;

        if (JSON_HEDLEY_UNLIKELY(input.empty()))
        {
            utf8_bytes[0] = std::char_traits<char>::eof();
            utf8_bytes_filled = 1;
        }
        else
        {
            // get the current character; converted to an unsigned type so that
            // a negative unit (wint_t is signed on some platforms) is not
            // mistaken for an ASCII character or for EOF
            const auto wc = static_cast<std::uint32_t>(input.get_character());

            if (wc <= 0x10FFFF)
            {
                // UTF-32 to UTF-8 encoding
                utf8_bytes_filled = 0;
                encode_utf8(static_cast<std::uint32_t>(wc), [&utf8_bytes, &utf8_bytes_filled](std::uint32_t byte)
                {
                    utf8_bytes[utf8_bytes_filled++] = static_cast<std::char_traits<char>::int_type>(byte);
                });
            }
            else
            {
                // A code point above U+10FFFF has no UTF-8 encoding. Passing the
                // unit through would narrow it to int, where 0xFFFFFFFF becomes
                // char_traits<char>::eof() and would end the input silently, so
                // emit a byte that is never valid UTF-8 and let the decoder
                // reject it.
                utf8_bytes[0] = 0xFF;
                utf8_bytes_filled = 1;
            }
        }
    }
};

template<typename BaseInputAdapter>
struct wide_string_input_helper<BaseInputAdapter, 2>
{
    // UTF-16
    static void fill_buffer(BaseInputAdapter& input,
                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
                            size_t& utf8_bytes_index,
                            size_t& utf8_bytes_filled)
    {
        utf8_bytes_index = 0;

        if (JSON_HEDLEY_UNLIKELY(input.empty()))
        {
            utf8_bytes[0] = std::char_traits<char>::eof();
            utf8_bytes_filled = 1;
        }
        else
        {
            // get the current character
            const auto wc = input.get_character();

            if (0xD800 > wc || wc >= 0xE000)
            {
                // a UTF-16 code unit outside the surrogate range is a valid
                // code point (at most U+FFFF) on its own
                utf8_bytes_filled = 0;
                encode_utf8(static_cast<std::uint32_t>(wc), [&utf8_bytes, &utf8_bytes_filled](std::uint32_t byte)
                {
                    utf8_bytes[utf8_bytes_filled++] = static_cast<std::char_traits<char>::int_type>(byte);
                });
            }
            else
            {
                // A supplementary code point is a high surrogate (0xD800..0xDBFF)
                // followed by a low surrogate (0xDC00..0xDFFF). A lone low
                // surrogate, a high surrogate at the end of the input, or a high
                // surrogate followed by any other unit is malformed UTF-16. In
                // that case the offending unit is passed through unchanged so the
                // UTF-8 decoder rejects it, matching how \uXXXX surrogate escapes
                // are handled in the lexer.
                bool valid_pair = false;
                if (wc <= 0xDBFF && JSON_HEDLEY_UNLIKELY(!input.empty()))
                {
                    // only consume the next unit if it completes the pair
                    const auto wc2 = static_cast<unsigned int>(*input.current);
                    if (0xDC00 <= wc2 && wc2 <= 0xDFFF)
                    {
                        input.get_character();
                        const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
                        utf8_bytes_filled = 0;
                        encode_utf8(charcode, [&utf8_bytes, &utf8_bytes_filled](std::uint32_t byte)
                        {
                            utf8_bytes[utf8_bytes_filled++] = static_cast<std::char_traits<char>::int_type>(byte);
                        });
                        valid_pair = true;
                    }
                }

                if (!valid_pair)
                {
                    // emit a byte that is never valid UTF-8 (see the UTF-32 case)
                    utf8_bytes[0] = 0xFF;
                    utf8_bytes_filled = 1;
                }
            }
        }
    }
};

// Wraps another input adapter to convert wide character types into individual bytes.
template<typename BaseInputAdapter, typename WideCharType>
class wide_string_input_adapter
{
  public:
    using char_type = char;

    wide_string_input_adapter(BaseInputAdapter base)
        : base_adapter(base) {}

    typename std::char_traits<char>::int_type get_character() noexcept
    {
        // check if the buffer needs to be filled
        if (utf8_bytes_index == utf8_bytes_filled)
        {
            fill_buffer<sizeof(WideCharType)>();

            JSON_ASSERT(utf8_bytes_filled > 0);
            JSON_ASSERT(utf8_bytes_index == 0);
        }

        // use buffer
        JSON_ASSERT(utf8_bytes_filled > 0);
        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
        return utf8_bytes[utf8_bytes_index++];
    }

    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
    template<class T>
    JSON_HEDLEY_NO_RETURN std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
    {
        JSON_THROW(parse_error::create(exception_id::unexpected_byte, 1, "wide string type cannot be interpreted as binary data", nullptr));
    }

  private:
    BaseInputAdapter base_adapter;

    template<size_t T>
    void fill_buffer()
    {
        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
    }

    /// a buffer for UTF-8 bytes
    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};

    /// index to the utf8_codes array for the next valid byte
    std::size_t utf8_bytes_index = 0;
    /// number of valid bytes in the utf8_codes array
    std::size_t utf8_bytes_filled = 0;
};

template<typename IteratorType, typename SentinelType = IteratorType, typename Enable = void>
struct iterator_input_adapter_factory
{
    using iterator_type = IteratorType;
    using sentinel_type = SentinelType;
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
    using adapter_type = iterator_input_adapter<iterator_type, sentinel_type>;

    static adapter_type create(IteratorType first, SentinelType last)
    {
        return adapter_type(std::move(first), std::move(last));
    }
};

// Detection: whether IteratorType and SentinelType can be compared with !=
template<typename IteratorType, typename SentinelType, typename = void>
struct can_compare_ne_impl : std::false_type {};

template<typename IteratorType, typename SentinelType>
struct can_compare_ne_impl < IteratorType, SentinelType,
       void_t < decltype(std::declval<IteratorType>() != std::declval<SentinelType>()) >>
           : std::true_type {};

// Workaround for reversed operator order
template<typename IteratorType, typename SentinelType, typename = void>
struct can_compare_ne_reversed : std::false_type {};

template<typename IteratorType, typename SentinelType>
struct can_compare_ne_reversed < IteratorType, SentinelType,
       void_t < decltype(std::declval<SentinelType>() != std::declval<IteratorType>()) >>
           : std::true_type {};

template<typename IteratorType, typename SentinelType>
struct can_compare_ne_either_order : std::integral_constant < bool,
    can_compare_ne_impl<IteratorType, SentinelType>::value ||
    can_compare_ne_reversed<IteratorType, SentinelType>::value > {};

// Two kinds of SentinelType are excluded explicitly:
//
// - std::nullptr_t: a literal `nullptr` passed as a trailing default argument
//   (e.g. parse(s, nullptr, ...)) must never be mistaken for a sentinel, and
//   some compilers (e.g. GCC 4.8) unreliably SFINAE the `operator!=` detection
//   above for std::nullptr_t against container/string types, which would
//   otherwise make such calls ambiguous with the compatible-input overload.
// - function pointers and functions: a parser callback passed as plain function
//   (e.g. parse(s, cb)) is never a sentinel. The callback's parameter types
//   make basic_json an associated class, so ADL finds the friend
//   operator!=(const_reference, ScalarType) of basic_json, which makes
//   `s != cb` well-formed (both convert to basic_json) and would select the
//   iterator/sentinel overload.
template<typename IteratorType, typename SentinelType>
struct can_compare_ne : std::integral_constant < bool,
    !std::is_same<SentinelType, std::nullptr_t>::value &&
    !std::is_function<typename std::remove_pointer<SentinelType>::type>::value &&
    can_compare_ne_either_order<IteratorType, SentinelType>::value > {};

template<typename T>
struct is_iterator_of_multibyte
{
    using value_type = typename std::iterator_traits<T>::value_type;
    enum // NOLINT(cppcoreguidelines-use-enum-class)
    {
        value = sizeof(value_type) > 1
    };
};

template<typename IteratorType, typename SentinelType>
struct iterator_input_adapter_factory<IteratorType, SentinelType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
{
    using iterator_type = IteratorType;
    using sentinel_type = SentinelType;
    using char_type = typename std::iterator_traits<iterator_type>::value_type;
    using base_adapter_type = iterator_input_adapter<iterator_type, sentinel_type>;
    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;

    static adapter_type create(IteratorType first, SentinelType last)
    {
        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
    }
};

/*!
@brief whether @a IteratorType is an iterator of std::string or of a
       std::vector of 1-byte elements

Their elements are contiguous, but before C++20 that cannot be detected from
the iterator type (std::contiguous_iterator), so an iterator pair of them would
be read one character at a time through the iterators. They are read as the
pointer range they are instead, as the containers themselves are (see the
container overload of input_adapter()). The types are matched exactly, so no
other iterator can be mistaken for one. (std::basic_string is only matched for
char: other character types need std::char_traits specializations that the
standard library need not have.)
*/
template<typename CharType>
struct is_byte_char_type
{
    // a member, not an integral_constant argument, which astyle misformats
    static constexpr bool value = sizeof(CharType) == 1 && std::is_integral<CharType>::value && !std::is_same<CharType, bool>::value;
};

template<typename IteratorType, typename CharType, bool IsByte = is_byte_char_type<CharType>::value>
struct is_std_contiguous_byte_iterator_impl : std::false_type {};

// (the containers are only named for byte types)
template<typename IteratorType, typename CharType>
struct is_std_contiguous_byte_iterator_impl<IteratorType, CharType, true>
{
    static constexpr bool value = !std::is_pointer<IteratorType>::value
                                  && (std::is_same<IteratorType, typename std::vector<CharType>::iterator>::value
                                      || std::is_same<IteratorType, typename std::vector<CharType>::const_iterator>::value
                                      || std::is_same<IteratorType, std::string::iterator>::value
                                      || std::is_same<IteratorType, std::string::const_iterator>::value);
};

template<typename IteratorType>
struct is_std_contiguous_byte_iterator
    : is_std_contiguous_byte_iterator_impl<IteratorType, typename std::remove_cv<typename std::iterator_traits<IteratorType>::value_type>::type> {};

template<typename IteratorType>
struct iterator_input_adapter_factory<IteratorType, IteratorType, enable_if_t<is_std_contiguous_byte_iterator<IteratorType>::value>>
{
    using iterator_type = IteratorType;
    using sentinel_type = IteratorType;
    using char_type = typename std::remove_cv<typename std::iterator_traits<iterator_type>::value_type>::type;
    using adapter_type = iterator_input_adapter<const char_type*>;

    static adapter_type create(IteratorType first, IteratorType last)
    {
        if (first == last)
        {
            // (an empty range must not be dereferenced)
            return adapter_type(nullptr, nullptr);
        }
        const char_type* const begin = std::addressof(*first);
        return adapter_type(begin, begin + (last - first));
    }
};

// General purpose iterator-based input (iterator+sentinel pair; SentinelType
// defaults to IteratorType for the common same-type case, but may differ for
// C++20 ranges-style iterator+sentinel pairs). Only enable for types that can
// be compared with !=.
template < typename IteratorType, typename SentinelType = IteratorType,
           typename = typename std::enable_if <
               can_compare_ne<IteratorType, SentinelType>::value >::type >
typename iterator_input_adapter_factory<IteratorType, SentinelType>::adapter_type input_adapter(IteratorType first, SentinelType last)
{
    using factory_type = iterator_input_adapter_factory<IteratorType, SentinelType>;
    return factory_type::create(first, last);
}

// The element type a container's data() points at, cv-qualifiers removed.
// Ill-formed - and therefore SFINAE-friendly - for types without data().
template<typename ContainerType>
using container_data_t = typename std::remove_cv<typename std::remove_pointer <
                         decltype(std::declval<const ContainerType&>().data()) >::type >::type;

// The container's own element type, cv-qualifiers removed. It is looked up on
// the bare type so it is also found when ContainerType is deduced as a
// reference by the forwarding-reference overload below.
template<typename ContainerType>
using container_value_t = typename std::remove_cv <
                          typename std::remove_cv<typename std::remove_reference<ContainerType>::type>::type::value_type >::type;

// Detect a container that stores its elements contiguously as single bytes
// (std::string, std::vector<char/unsigned char>, std::array<char, N>,
// std::string_view, ...). Such inputs are wrapped in a pointer-based adapter so
// they benefit from the contiguous fast paths (bulk string scanning, memcpy for
// binary formats) in every C++ standard - not only in C++20, where the standard
// library iterators model std::contiguous_iterator and are detected directly.
//
// data() and size() on their own would be duck typing: they say nothing about
// size() counting the units data() points at, and reading [data(), data() +
// size()) as bytes would be wrong for a type where it does not. Requiring the
// container's own value_type to be that same single-byte element ties the two
// together; every contiguous standard container satisfies it. Anything else
// keeps the iterator-based adapter, which is always correct - only slower.
template<typename ContainerType, typename = void>
struct is_contiguous_byte_container : std::false_type {};

template<typename ContainerType>
struct is_contiguous_byte_container < ContainerType, void_t <
    container_data_t<ContainerType>,
    container_value_t<ContainerType>,
decltype(std::declval<const ContainerType&>().size()) >>
            : std::integral_constant < bool,
        std::is_pointer<decltype(std::declval<const ContainerType&>().data())>::value&&
        std::is_integral<container_data_t<ContainerType>>::value&&
        sizeof(container_data_t<ContainerType>) == 1 &&
        std::is_same<container_data_t<ContainerType>, container_value_t<ContainerType>>::value > {};

// Convenience shorthand from container to iterator
// Enables ADL on begin(container) and end(container)
// Encloses the using declarations in namespace for not to leak them to outside scope

namespace container_input_adapter_factory_impl
{

using std::begin;
using std::end;

template<typename ContainerType, typename Enable = void>
struct container_input_adapter_factory {};

template<typename ContainerType>
struct container_input_adapter_factory< ContainerType,
       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
       {
           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));

           static adapter_type create(ContainerType&& container)
{
    // container is forwarded twice on purpose: the resulting begin/end
    // iterator types must match adapter_type, computed the same way
    // NOLINTNEXTLINE(bugprone-use-after-move,hicpp-invalid-access-moved)
    return input_adapter(begin(std::forward<ContainerType>(container)), end(std::forward<ContainerType>(container)));
}
       };

}  // namespace container_input_adapter_factory_impl

// General container path (iterator-based). Contiguous single-byte containers
// are excluded here and routed through the pointer-based overload below.
template < typename ContainerType,
           enable_if_t < !is_contiguous_byte_container<ContainerType>::value, int > = 0 >
typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType && container)
{
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
}

// Contiguous single-byte containers (std::string, std::vector<char>, ...) are
// wrapped in a pointer-based adapter so the contiguous fast paths apply in every
// standard. The pointer keeps the container's own element type (const char* for
// std::string, const std::uint8_t* for std::vector<std::uint8_t>, ...), so the
// resulting char_type - and therefore the parsing behavior - is byte-for-byte
// identical to the iterator-based path; only the raw pointer additionally
// enables the bulk fast paths. The container outlives the adapter for the whole
// parse (temporaries live until the end of the full expression), exactly as the
// iterators it replaces did.
template < typename ContainerType,
           enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
auto input_adapter(const ContainerType& container)
-> decltype(input_adapter(container.data(), container.data() + container.size()))
{
    return input_adapter(container.data(), container.data() + container.size());
}

// specialization for std::string
using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));

#ifndef JSON_NO_IO
// Special cases with fast paths
inline file_input_adapter input_adapter(std::FILE* file)
{
    if (file == nullptr)
    {
        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, empty_input_message(), nullptr));
    }
    return file_input_adapter(file);
}

inline input_stream_adapter input_adapter(std::istream& stream)
{
    if (stream.rdbuf() == nullptr)
    {
        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, empty_input_message(), nullptr));
    }
    return input_stream_adapter(stream);
}

inline input_stream_adapter input_adapter(std::istream&& stream)
{
    return input_adapter(stream);
}
#endif  // JSON_NO_IO

using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));

// Null-delimited strings, and the like.
template < typename CharT,
           typename std::enable_if <
               std::is_pointer<CharT>::value&&
               !std::is_array<CharT>::value&&
               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
               sizeof(typename std::remove_pointer<CharT>::type) == 1,
               int >::type = 0 >
contiguous_bytes_input_adapter input_adapter(CharT b)
{
    if (b == nullptr)
    {
        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, empty_input_message(), nullptr));
    }
    auto length = std::strlen(reinterpret_cast<const char*>(b));
    const auto* ptr = reinterpret_cast<const char*>(b);
    return input_adapter(ptr, ptr + length); // cppcheck-suppress[nullPointerArithmeticRedundantCheck]
}

template<typename T, std::size_t N>
auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
{
#if JSON_STRICT_NUL_HANDLING
    // A text-literal array from string-literal initialization (e.g.
    // json::parse("123") or json::parse(L"123")) carries a trailing '\0'
    // contributed by the compiler, not by the source text; drop exactly that
    // one byte so it is not mistaken for real trailing data. This covers all
    // character types that string literals can use: char, wchar_t, char16_t,
    // char32_t, and (C++20) char8_t. Every other element type (unsigned char,
    // std::uint8_t, ...) keeps the full extent unconditionally, since a
    // trailing zero byte there is genuine data (e.g. CBOR/MessagePack). This
    // intentionally does not strlen()-scan the array (as the pointer overload
    // above does for a null-delimited string): for an array that is not
    // NUL-terminated within its bounds, that would read past the end of the
    // array.
    using char_t = typename std::remove_cv<T>::type;
    constexpr bool is_text_literal_type = std::is_same<char_t, char>::value
                                          || std::is_same<char_t, wchar_t>::value
                                          || std::is_same<char_t, char16_t>::value
                                          || std::is_same<char_t, char32_t>::value
#if defined(__cpp_char8_t)
                                          || std::is_same<char_t, char8_t>::value
#endif
                                          ;
    if (is_text_literal_type && N > 0 && array[N - 1] == 0)
    {
        return input_adapter(array, array + N - 1);
    }
#endif
    return input_adapter(array, array + N);
}

// This class only handles inputs that construct a contiguous_bytes_input_adapter
// (e.g. span_input_adapter). It's required so that expressions like {ptr, len}
// can be implicitly cast to the correct adapter.
class span_input_adapter
{
  public:
    template < typename CharT,
               typename std::enable_if <
                   std::is_pointer<CharT>::value&&
                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
                   int >::type = 0 >
    span_input_adapter(CharT b, std::size_t l)
        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}

    template<class IteratorType,
             typename std::enable_if<
                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
                 int>::type = 0>
    span_input_adapter(IteratorType first, IteratorType last)
        : ia(input_adapter(first, last)) {}

    contiguous_bytes_input_adapter&& get()
    {
        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
    }

  private:
    contiguous_bytes_input_adapter ia;
};

}  // namespace detail
NLOHMANN_JSON_NAMESPACE_END