Add json_document and json_view: node index, parser, and document

Add json_document and json_view, a read-only, zero-copy index of a
JSON text, as the first public slice of the zero-copy view (#5295).

A parse produces a flat array of 16-byte nodes in document order,
one per value and one per object key. Strings stay in the source
text; escaped strings are decoded into an arena. Integers are
converted while their digits are in the cache; floats keep only
their digit layout and are converted on read. Containers store the
size of their subtree, so a reader can step over one in constant
time. A document makes a handful of allocations, however many
values it has.

The parser accepts exactly what json::parse accepts, with every
combination of ignore_comments and ignore_trailing_commas, with and
without a trailing NUL, and under JSON_STRICT_NUL_HANDLING. It is
portable C++11 and does not depend on byte order.

basic_json_document adds parse, parse_copy, accept, read (reuses a
document's memory), root, is_discarded, source, owns_source,
node_count, memory_usage, and shrink_to_fit. basic_json_view adds
type, the is_* queries, operator bool, size, empty, materialize,
and source_offset. A parse error throws the same exception
basic_json::parse would throw for the same input, message and
position included.

detail::abi_config keeps JSON_STRICT_NUL_HANDLING and
JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON readable after json.hpp
undefines them, in the ABI namespace so they always match the
basic_json in use.

A NUL byte that ends a // comment is the end of the input, as in
parse() since #5696.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

include/nlohmann/detail/abi_config.hpp

@@ -0,0 +1,34 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief the configuration macros that change the library's behavior
+
+json.hpp undefines these macros at its end (see macro_unscope.hpp), so code
+that builds on the library after it (json_view.hpp) reads them here. Like the
+macros, they are part of the ABI namespace, so they always match the
+basic_json they are used with.
+*/
+struct abi_config
+{
+    /// JSON_STRICT_NUL_HANDLING: a null byte is an error, not the end of input
+    static constexpr bool strict_nul_handling = JSON_STRICT_NUL_HANDLING != 0;
+    /// JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    static constexpr bool legacy_discarded_value_comparison = JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON != 0;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/document_data.hpp

@@ -0,0 +1,130 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <array> // array
+#include <cstddef> // size_t
+#include <cstring> // memcpy
+#include <new> // operator new, placement new
+#include <string> // string
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+#include <nlohmann/detail/view/node.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// storage of a parsed document; heap-allocated (header and an initial node
+/// array in one block) so that views survive moves of the owning document
+struct document_data
+{
+    const char* src = nullptr;
+    std::size_t size = 0;
+    node* tape = nullptr;
+    std::size_t tape_size = 0;
+    std::size_t tape_cap = 0;
+    node* inline_tape = nullptr; ///< node array allocated together with this header
+    std::size_t inline_cap = 0;
+    std::string arena{}; ///< decoded strings that contained escapes // NOLINT(readability-redundant-member-init)
+    std::string owned{}; ///< owned copy of the input, if any // NOLINT(readability-redundant-member-init)
+    std::array<const char*, 4> base = {{nullptr, nullptr, nullptr, nullptr}}; ///< string bases: source, arena (indexed by flags & node_flags::storage)
+    bool discarded = true;
+
+    /// one allocation for the header and room for `nodes` nodes; large
+    /// documents get a separate node array instead (so it can be trimmed)
+    static document_data* create(std::size_t nodes)
+    {
+        nodes = nodes <= 256 ? nodes : 0;
+        void* mem = ::operator new (sizeof(document_data) + (nodes * sizeof(node)));
+        auto* d = new (mem) document_data(); // NOLINT(cppcoreguidelines-owning-memory): owned by the returned pointer, freed by deleter
+        // (aligned: sizeof is a multiple of the alignment; through void*, as GCC's -Wcast-align wants)
+        d->inline_tape = static_cast<node*>(static_cast<void*>(static_cast<char*>(mem) + sizeof(document_data))); // NOLINT(bugprone-casting-through-void)
+        d->inline_cap = nodes;
+        d->tape = d->inline_tape;
+        d->tape_cap = nodes;
+        return d;
+    }
+
+    struct deleter
+    {
+        void operator()(document_data* d) const noexcept
+        {
+            d->~document_data();
+            ::operator delete (d);
+        }
+    };
+
+    document_data() noexcept = default;
+    document_data(const document_data&) = delete;
+    document_data(document_data&&) = delete;
+    document_data& operator=(const document_data&) = delete;
+    document_data& operator=(document_data&&) = delete;
+    ~document_data()
+    {
+        release();
+    }
+
+    void release() noexcept
+    {
+        if (tape != inline_tape)
+        {
+            ::operator delete (tape);
+        }
+        tape = inline_tape;
+        tape_cap = inline_cap;
+    }
+
+    /// make room for n nodes; keeps the first tape_size nodes
+    void reserve(std::size_t n)
+    {
+        if (n <= tape_cap)
+        {
+            return;
+        }
+        node* fresh = static_cast<node*>(::operator new (n * sizeof(node)));
+        if (tape_size != 0)
+        {
+            std::memcpy(fresh, tape, tape_size * sizeof(node));
+        }
+        release();
+        tape = fresh;
+        tape_cap = n;
+    }
+
+    const char* str(const node& n) const noexcept
+    {
+        return base[n.flags & node_flags::storage] + n.off;
+    }
+
+    /// the node after n's subtree (containers span `next` nodes, scalars one)
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* after(const node* n) noexcept
+    {
+        return n + (is_container(*n) ? n->next : 1u);
+    }
+
+    /// first element (array) or first key (object) of a container
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* first_child(const node* n) noexcept
+    {
+        return n + 1;
+    }
+
+    /// end of the elements of a container
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* child_end(const node* n) noexcept
+    {
+        return n + n->next;
+    }
+};
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/errors.hpp

@@ -0,0 +1,85 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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> // min
+#include <cstddef> // size_t
+#include <string> // string
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/builder.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+// Exceptions are thrown out of line, so that the accessors that may throw stay
+// small enough to be inlined.
+
+[[noreturn]] NLOHMANN_VIEW_NOINLINE inline void throw_type_error(int id, const char* prefix, const char* type)
+{
+    NLOHMANN_VIEW_THROW(type_error::create(id, concat(prefix, type), nullptr));
+}
+
+[[noreturn]] NLOHMANN_VIEW_NOINLINE inline void throw_out_of_range(int id, const std::string& msg)
+{
+    NLOHMANN_VIEW_THROW(out_of_range::create(id, msg, nullptr));
+}
+
+[[noreturn]] NLOHMANN_VIEW_NOINLINE inline void throw_invalid_iterator(int id, const char* msg)
+{
+    NLOHMANN_VIEW_THROW(invalid_iterator::create(id, msg, nullptr));
+}
+
+/*!
+@brief throw the exception BasicJsonType::parse would throw for this input
+
+The view accepts exactly the inputs parse() accepts, so on a failure the
+library parser is run on the same bytes: it throws the exception parse() would
+throw, with the same message, position, and "last read" token. The error path
+is cold, so this costs nothing on valid input. Should parse() accept the input
+nevertheless (a bug), the view's own failure is reported.
+*/
+template<typename BasicJsonType>
+[[noreturn]] NLOHMANN_VIEW_NOINLINE void throw_parse_failure(const parse_failure& f, const char* src, std::size_t size,
+        bool ignore_comments, bool ignore_trailing_commas)
+{
+    if (f.code == error_code::input_too_large)
+    {
+        // LCOV_EXCL_START (4 GiB)
+        NLOHMANN_VIEW_THROW(out_of_range::create(416, "input of 4 GiB or more is not supported by json_document", nullptr));
+        // LCOV_EXCL_STOP
+    }
+    const BasicJsonType accepted = BasicJsonType::parse(src, src + size, nullptr, true, ignore_comments, ignore_trailing_commas);
+    // LCOV_EXCL_START (only if parse() accepts what the view rejects: a bug)
+    static_cast<void>(accepted);
+
+    position_t pos;
+    const std::size_t off = (std::min)(f.offset, size);
+    pos.chars_read_total = off + 1;
+    std::size_t line_start = 0;
+    for (std::size_t i = 0; i < off; ++i)
+    {
+        if (src[i] == '\n')
+        {
+            ++pos.lines_read;
+            line_start = i + 1;
+        }
+    }
+    pos.chars_read_current_line = off + 1 - line_start;
+    NLOHMANN_VIEW_THROW(parse_error::create(101, pos, "syntax error while parsing value", nullptr));
+    // LCOV_EXCL_STOP
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/input.hpp

@@ -0,0 +1,88 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <string> // basic_string, char_traits, string
+#include <type_traits> // decay, integral_constant, is_array, is_lvalue_reference, is_pointer, is_same, remove_reference
+#include <utility> // forward
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+#if NLOHMANN_VIEW_HAS_CPP_17
+    #include <string_view> // string_view
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// how a document takes its input
+enum class input_kind
+{
+    move_string,  ///< rvalue std::string: owned without a copy
+    c_string,     ///< const char* (NUL-terminated): borrowed
+    char_array,   ///< char array (e.g. a string literal): borrowed
+    borrow_range, ///< lvalue contiguous byte container, or std::string_view: borrowed
+    copy_range,   ///< rvalue contiguous byte container: copied
+    adapter,      ///< anything else parse() accepts (streams, wide strings, ...): read into a buffer
+};
+
+template<typename InputType>
+struct classify_input
+{
+    using R = typename std::remove_reference<InputType>::type;
+    using D = typename std::decay<InputType>::type;
+    static constexpr bool is_rvalue = !std::is_lvalue_reference<InputType>::value;
+    static constexpr bool is_bytes = is_contiguous_byte_container<D>::value;
+#if NLOHMANN_VIEW_HAS_CPP_17
+    static constexpr bool is_string_view = std::is_same<D, std::string_view>::value;
+#else
+    static constexpr bool is_string_view = false;
+#endif
+    // NOLINTBEGIN(readability-avoid-nested-conditional-operator): a constant expression of C++11
+    static constexpr input_kind value =
+        std::is_array<R>::value ? input_kind::char_array
+        : std::is_pointer<D>::value ? input_kind::c_string
+        : (is_rvalue && std::is_same<D, std::string>::value) ? input_kind::move_string
+        : (is_bytes && (!is_rvalue || is_string_view)) ? input_kind::borrow_range
+        : is_bytes ? input_kind::copy_range
+        : input_kind::adapter;
+    // NOLINTEND(readability-avoid-nested-conditional-operator)
+};
+
+/// std::basic_string guarantees a NUL at data()[size()] (the parser's sentinel)
+template<typename T>
+struct is_std_string : std::false_type {};
+
+template<typename Traits, typename Alloc>
+struct is_std_string<std::basic_string<char, Traits, Alloc>> : std::true_type {};
+
+/// drain a json input adapter (UTF-16/32 inputs arrive as UTF-8)
+template<typename Adapter>
+std::string collect_adapter(Adapter ia)
+{
+    std::string buf;
+    for (;;)
+    {
+        const auto ch = ia.get_character();
+        if (ch == std::char_traits<char>::eof())
+        {
+            break;
+        }
+        buf.push_back(static_cast<char>(ch));
+    }
+    return buf;
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/macro_scope.hpp

@@ -0,0 +1,71 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// Macros of json_view.hpp and its detail headers. json.hpp undefines its own
+// macros at its end (macro_unscope.hpp), so the view defines the few it needs
+// under its own prefix; json_view.hpp undefines them all at its end
+// (detail/view/macro_unscope.hpp). Configuration that json.hpp undefines is
+// read from detail::abi_config instead.
+
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #define NLOHMANN_VIEW_HAS_CPP_17 1
+#else
+    #define NLOHMANN_VIEW_HAS_CPP_17 0
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define NLOHMANN_VIEW_LIKELY(x) __builtin_expect(!!(x), 1)
+    #define NLOHMANN_VIEW_UNLIKELY(x) __builtin_expect(!!(x), 0)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE inline __attribute__((always_inline))
+    #define NLOHMANN_VIEW_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+    #define NLOHMANN_VIEW_LIKELY(x) (x)
+    #define NLOHMANN_VIEW_UNLIKELY(x) (x)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE __forceinline
+    #define NLOHMANN_VIEW_NOINLINE __declspec(noinline)
+#else
+    #define NLOHMANN_VIEW_LIKELY(x) (x)
+    #define NLOHMANN_VIEW_UNLIKELY(x) (x)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE inline
+    #define NLOHMANN_VIEW_NOINLINE
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define NLOHMANN_VIEW_NODISCARD __attribute__((warn_unused_result))
+#elif defined(_MSC_VER)
+    #define NLOHMANN_VIEW_NODISCARD _Check_return_
+#else
+    #define NLOHMANN_VIEW_NODISCARD
+#endif
+
+// exceptions as in json.hpp (JSON_NOEXCEPTION, JSON_THROW_USER)
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define NLOHMANN_VIEW_THROW(exception) throw exception
+#else
+    #include <cstdlib>
+    // (the exception is built first, so that the arguments of the throwing
+    // helpers count as used; the program ends anyway)
+    #define NLOHMANN_VIEW_THROW(exception) (static_cast<void>(exception), std::abort())
+#endif
+#if defined(JSON_THROW_USER)
+    #undef NLOHMANN_VIEW_THROW
+    #define NLOHMANN_VIEW_THROW JSON_THROW_USER
+#endif
+
+// the parser stores a node's first word at once where the layout of `node` is
+// known to be little-endian (MSVC targets are); elsewhere field by field
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || defined(_MSC_VER)
+    #define NLOHMANN_VIEW_LITTLE_ENDIAN 1
+#else
+    #define NLOHMANN_VIEW_LITTLE_ENDIAN 0
+#endif
+
+/// sixteen checks at fixed offsets 0..15
+#define NLOHMANN_VIEW_REPEAT16(X) X(0) X(1) X(2) X(3) X(4) X(5) X(6) X(7) X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15)

include/nlohmann/detail/view/macro_unscope.hpp

@@ -0,0 +1,21 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// undefine the macros of detail/view/macro_scope.hpp (at the end of json_view.hpp)
+
+#undef NLOHMANN_VIEW_HAS_CPP_17
+#undef NLOHMANN_VIEW_LIKELY
+#undef NLOHMANN_VIEW_UNLIKELY
+#undef NLOHMANN_VIEW_ALWAYS_INLINE
+#undef NLOHMANN_VIEW_NOINLINE
+#undef NLOHMANN_VIEW_NODISCARD
+#undef NLOHMANN_VIEW_THROW
+#undef NLOHMANN_VIEW_LITTLE_ENDIAN
+#undef NLOHMANN_VIEW_REPEAT16

include/nlohmann/detail/view/materialize.hpp

@@ -0,0 +1,131 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <cstdint> // int64_t, uint8_t
+#include <string> // string
+#include <vector> // vector
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/document_data.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+#include <nlohmann/detail/view/node.hpp>
+#include <nlohmann/detail/view/number.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/*!
+@brief the basic_json value of the subtree at n
+
+The subtree is replayed into the SAX handler that parse() uses to build its
+values, so the result is the value parse() would produce: duplicate keys keep
+the last value, and with JSON_DIAGNOSTICS the parent pointers are set. It is
+iterative, so the nesting depth is limited by memory only, as for parse().
+Without a lexer the handler records no source positions
+(JSON_DIAGNOSTIC_POSITIONS).
+*/
+template<typename BasicJsonType>
+BasicJsonType materialize(const document_data& d, const node* n)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using sax_t = json_sax_dom_parser<BasicJsonType, iterator_input_adapter<const char*>>;
+
+    BasicJsonType result;
+    sax_t sax(result, true);
+    const string_t no_token{};
+    // the ends of the open containers, and whether they are objects
+    std::vector<std::pair<const node*, bool>> open;
+    for (;;)
+    {
+        switch (static_cast<value_t>(n->kind))
+        {
+            case value_t::object:
+            case value_t::array:
+            {
+                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                if (object)
+                {
+                    sax.start_object(n->len);
+                }
+                else
+                {
+                    sax.start_array(n->len);
+                }
+                open.emplace_back(document_data::child_end(n), object);
+                n = document_data::first_child(n);
+                break;
+            }
+            case value_t::string:
+            {
+                string_t s(d.str(*n), n->len);
+                sax.string(s);
+                ++n;
+                break;
+            }
+            case value_t::number_integer:
+                sax.number_integer(static_cast<typename BasicJsonType::number_integer_t>(static_cast<std::int64_t>(integer_bits(*n))));
+                ++n;
+                break;
+            case value_t::number_unsigned:
+                sax.number_unsigned(static_cast<typename BasicJsonType::number_unsigned_t>(integer_bits(*n)));
+                ++n;
+                break;
+            case value_t::number_float:
+                sax.number_float(float_value<typename BasicJsonType::number_float_t>(d.str(*n), *n), no_token);
+                ++n;
+                break;
+            case value_t::boolean:
+                sax.boolean((n->flags & node_flags::is_true) != 0);
+                ++n;
+                break;
+            case value_t::null:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                sax.null();
+                ++n;
+                break;
+        }
+        for (;;)
+        {
+            if (open.empty())
+            {
+                return result;
+            }
+            if (n != open.back().first)
+            {
+                break;
+            }
+            if (open.back().second)
+            {
+                sax.end_object();
+            }
+            else
+            {
+                sax.end_array();
+            }
+            open.pop_back();
+        }
+        if (open.back().second)
+        {
+            // the key of the next member
+            string_t key(d.str(*n), n->len);
+            sax.key(key);
+            ++n;
+        }
+    }
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/node.hpp

@@ -0,0 +1,97 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+// the node kinds are value_t values; the tests of is_container() and of the
+// number kinds depend on this numbering
+static_assert(static_cast<std::uint8_t>(value_t::null) == 0 && static_cast<std::uint8_t>(value_t::object) == 1
+              && static_cast<std::uint8_t>(value_t::array) == 2 && static_cast<std::uint8_t>(value_t::string) == 3
+              && static_cast<std::uint8_t>(value_t::boolean) == 4 && static_cast<std::uint8_t>(value_t::number_integer) == 5
+              && static_cast<std::uint8_t>(value_t::number_unsigned) == 6 && static_cast<std::uint8_t>(value_t::number_float) == 7,
+              "the node format depends on the numbering of value_t");
+
+/// node flags
+struct node_flags
+{
+    static constexpr std::uint8_t escaped = 1; ///< string payload lives in the decode arena, not the source
+    static constexpr std::uint8_t storage = 3; ///< mask: where a string or number token lives (index into document_data::base)
+    static constexpr std::uint8_t is_true = 4; ///< boolean value
+};
+
+/// One entry of the flat index, in document order. An object's members are
+/// stored as key node followed by the value's subtree. Integers keep their
+/// converted 64-bit value in the len/next bytes (the node after a scalar is
+/// always the next one, and the token length follows from `extra`).
+struct node
+{
+    std::uint8_t kind;   ///< value_t
+    std::uint8_t flags;  ///< node_flags
+    std::uint16_t extra; ///< numbers: integer digits (low byte) and fraction digits (high byte), 255 = "many"; otherwise 0
+    std::uint32_t off;   ///< source offset (string content, number token, literal, bracket); arena offset if node_flags::escaped
+    std::uint32_t len;   ///< string: decoded bytes; float: token bytes; array/object: element count
+    std::uint32_t next;  ///< array/object: number of nodes of the subtree (its extent in the enclosing sequence)
+};
+static_assert(sizeof(node) == 16, "node must stay 16 bytes");
+
+NLOHMANN_VIEW_ALWAYS_INLINE bool is_container(const node& n) noexcept
+{
+    return static_cast<unsigned>(n.kind) - 1u <= 1u;
+}
+
+/// the converted value of an integer node (stored in len/next)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t integer_bits(const node& n) noexcept
+{
+    std::uint64_t v = 0;
+    std::memcpy(&v, reinterpret_cast<const unsigned char*>(&n) + 8, 8); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    return v;
+}
+
+NLOHMANN_VIEW_ALWAYS_INLINE void set_integer_bits(node& n, std::uint64_t v) noexcept
+{
+    std::memcpy(reinterpret_cast<unsigned char*>(&n) + 8, &v, 8); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+}
+
+/// token length of a number node
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t number_length(const node& n) noexcept
+{
+    return n.kind == static_cast<std::uint8_t>(value_t::number_float) ? n.len
+           : (n.extra & 0xFFu) + (n.kind == static_cast<std::uint8_t>(value_t::number_integer) ? 1u : 0u);
+}
+
+/// estimated number of nodes for an input of `size` bytes (one node per ~12
+/// bytes covers typical documents without regrowth)
+inline std::size_t estimate_nodes(std::size_t size) noexcept
+{
+    return (size / 12) + 16;
+}
+
+/// estimated number of nodes for the input [src, src + size): pretty-printed
+/// input (whitespace after the first byte) needs about a node per 12 bytes,
+/// minified input up to one per 4 (yyjson tells the two apart the same way)
+inline std::size_t estimate_nodes(const char* src, std::size_t size) noexcept
+{
+    return size >= 2 && (src[1] == ' ' || src[1] == '\n' || src[1] == '\r' || src[1] == '\t') ? estimate_nodes(size) : (size / 4) + 16;
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/number.hpp

@@ -0,0 +1,67 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <cstddef> // size_t
+#include <string> // string
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+#include <nlohmann/detail/view/node.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/*!
+@brief the value of the float token of a node, as parse() converts it
+
+Uses the lexer's conversion (detail::convert_float), so that the values are
+bit-identical to parse(): float and double are converted without allocation
+and independent of the locale. The digit layout recorded while parsing locates
+the decimal point and the exponent without scanning the token.
+*/
+template<typename FloatType>
+NLOHMANN_VIEW_NOINLINE FloatType float_value(const char* first, const node& n)
+{
+    const char* const last = first + n.len;
+    const std::size_t neg = first[0] == '-' ? 1 : 0;
+    const std::size_t int_digits = n.extra & 0xFFu;
+    const std::size_t frac_digits = n.extra >> 8u;
+    std::size_t dot = std::string::npos;
+    std::size_t mantissa_end = n.len;
+    if (int_digits != 255 && frac_digits != 255)
+    {
+        dot = frac_digits != 0 ? neg + int_digits : std::string::npos;
+        mantissa_end = neg + int_digits + (frac_digits != 0 ? 1 + frac_digits : 0);
+    }
+    else
+    {
+        // more digits than the layout records: locate them
+        for (std::size_t i = 0; i < n.len; ++i)
+        {
+            if (first[i] == '.')
+            {
+                dot = i;
+            }
+            else if (first[i] == 'e' || first[i] == 'E')
+            {
+                mantissa_end = i;
+                break;
+            }
+        }
+    }
+    return convert_float<FloatType>(first, last, dot, mantissa_end);
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/scan.hpp

@@ -0,0 +1,189 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2020 YaoYuan <https://github.com/ibireme/yyjson>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint64_t
+#include <cstring> // memcpy
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+// Scanning primitives of the view's parser. The unrolled checks at fixed
+// offsets follow yyjson (https://github.com/ibireme/yyjson, MIT license): the
+// loads do not depend on each other, so the CPU can run ahead. Words are read
+// with read_eight_bytes(), so nothing here depends on the byte order.
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// 1 for bytes that may appear verbatim in a string: 0x20..0x7F except '"' and '\\'
+inline const std::uint8_t* string_plain() noexcept
+{
+    static const std::array<std::uint8_t, 256> table =
+    {
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00..0x1F
+            1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20..0x3F ('"')
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 0x40..0x5F ('\\')
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60..0x7F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x80..0x9F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xA0..0xBF
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xC0..0xDF
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xE0..0xFF
+        }
+    };
+    return table.data();
+}
+
+NLOHMANN_VIEW_ALWAYS_INLINE bool is_digit(unsigned char c) noexcept
+{
+    return static_cast<unsigned char>(c - '0') <= 9;
+}
+
+/// two bytes as they are in memory (only compared with byte-symmetric patterns)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint16_t load16(const unsigned char* p) noexcept
+{
+    std::uint16_t w = 0;
+    std::memcpy(&w, p, 2);
+    return w;
+}
+
+/// Advance over plain string bytes and well-formed UTF-8. Stops at a quote,
+/// a backslash, a control character, ill-formed UTF-8, or the end. The first
+/// 16 bytes are checked one by one, so that the position advances by
+/// constants in predicted branches (most strings are short); longer runs
+/// continue eight bytes at a time.
+NLOHMANN_VIEW_ALWAYS_INLINE const unsigned char* scan_string_run(const unsigned char* p, const unsigned char* e) noexcept
+{
+    const std::uint8_t* plain = string_plain();
+    for (;;)
+    {
+        if (e - p >= 16)
+        {
+#define NLOHMANN_VIEW_STEP(i) if (NLOHMANN_VIEW_LIKELY(plain[p[i]] != 0)) {} else { p += (i); goto stop; }
+            NLOHMANN_VIEW_REPEAT16(NLOHMANN_VIEW_STEP)
+#undef NLOHMANN_VIEW_STEP
+            p += 16;
+            while (e - p >= 8)
+            {
+                const std::uint64_t special = swar_string_special(read_eight_bytes(p));
+                if (special != 0)
+                {
+                    p += count_trailing_zeros(special) / 8;
+                    goto stop;
+                }
+                p += 8;
+            }
+            continue;
+        }
+        while (p != e && plain[*p] != 0)
+        {
+            ++p;
+        }
+        if (p == e)
+        {
+            return p;
+        }
+stop:
+        if (*p < 0x80)
+        {
+            return p; // quote, backslash, or control character
+        }
+        // non-ASCII: a run of well-formed sequences (the library's check, so
+        // that exactly what json::parse accepts is accepted)
+        do
+        {
+            const std::size_t n = validate_one_utf8(p, static_cast<std::size_t>(e - p));
+            if (n == 0)
+            {
+                return p;
+            }
+            p += n;
+        }
+        while (p != e && *p >= 0x80);
+    }
+}
+
+/// advance over ASCII digits
+NLOHMANN_VIEW_ALWAYS_INLINE const unsigned char* skip_digits(const unsigned char* p, const unsigned char* e) noexcept
+{
+    while (e - p >= 16)
+    {
+#define NLOHMANN_VIEW_STEP(i) if (NLOHMANN_VIEW_LIKELY(is_digit(p[i]))) {} else { return p + (i); }
+        NLOHMANN_VIEW_REPEAT16(NLOHMANN_VIEW_STEP)
+#undef NLOHMANN_VIEW_STEP
+        p += 16;
+    }
+    while (p != e && is_digit(*p))
+    {
+        ++p;
+    }
+    return p;
+}
+
+/// powers of ten up to 10^19 as integers
+inline std::uint64_t int_pow10(unsigned k) noexcept
+{
+    static const std::array<std::uint64_t, 20> table =
+    {
+        {
+            1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u,
+            10000000000u, 100000000000u, 1000000000000u, 10000000000000u, 100000000000000u, 1000000000000000u,
+            10000000000000000u, 100000000000000000u, 1000000000000000000u, 10000000000000000000u
+        }
+    };
+    return table[k];
+}
+
+/// value of 0 < k < 8 digits at p in one step if [p, p + 8) lies below
+/// limit, else one digit at a time (whole blocks of eight digits are read by
+/// parse_upto19() directly)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t parse_upto8(const unsigned char* p, unsigned k, const unsigned char* limit) noexcept
+{
+    if (NLOHMANN_VIEW_LIKELY(limit - p >= 8))
+    {
+        // move the k digits to the top and pad the vacated low bytes with '0'
+        const unsigned shift = 8 * (8 - k);
+        return parse_eight_digits((read_eight_bytes(p) << shift) | (0x3030303030303030u >> (8 * k)));
+    }
+    std::uint64_t v = 0;
+    for (unsigned i = 0; i < k; ++i)
+    {
+        v = (v * 10) + static_cast<std::uint64_t>(p[i] - '0');
+    }
+    return v;
+}
+
+/// value of k <= 19 digits at p
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t parse_upto19(const unsigned char* p, unsigned k, const unsigned char* limit) noexcept
+{
+    std::uint64_t w = 0;
+    while (k >= 8)
+    {
+        // (eight digits of the token: they lie below limit)
+        w = (w * 100000000u) + parse_eight_digits(read_eight_bytes(p));
+        p += 8;
+        k -= 8;
+    }
+    if (k != 0)
+    {
+        w = (w * int_pow10(k)) + parse_upto8(p, k, limit);
+    }
+    return w;
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/view/string_ref.hpp

@@ -0,0 +1,113 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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> // min
+#include <cstddef> // size_t
+#include <cstring> // memcmp, strlen
+#include <string> // basic_string
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+#if NLOHMANN_VIEW_HAS_CPP_17
+    #include <string_view> // string_view
+#endif
+#ifndef JSON_NO_IO
+    #include <ostream> // ostream
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+#if NLOHMANN_VIEW_HAS_CPP_17
+using string_ref = std::string_view;
+#else
+/// minimal C++11 stand-in for std::string_view
+class string_ref
+{
+  public:
+    using size_type = std::size_t;
+    using const_iterator = const char*;
+
+    string_ref() noexcept = default;
+    // s must be null-terminated, as for std::string_view(const char*)
+    // flawfinder: ignore
+    string_ref(const char* s) : m_data(s), m_size(std::strlen(s)) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+    string_ref(const char* s, std::size_t n) noexcept : m_data(s), m_size(n) {}
+    template<typename Traits, typename Alloc>
+    string_ref(const std::basic_string<char, Traits, Alloc>& s) noexcept : m_data(s.data()), m_size(s.size()) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+
+    const char* data() const noexcept
+    {
+        return m_data;
+    }
+    std::size_t size() const noexcept
+    {
+        return m_size;
+    }
+    std::size_t length() const noexcept
+    {
+        return m_size;
+    }
+    bool empty() const noexcept
+    {
+        return m_size == 0;
+    }
+    const char* begin() const noexcept
+    {
+        return m_data;
+    }
+    const char* end() const noexcept
+    {
+        return m_data + m_size;
+    }
+    char operator[](std::size_t i) const noexcept
+    {
+        return m_data[i];
+    }
+
+    template<typename Traits, typename Alloc>
+    explicit operator std::basic_string<char, Traits, Alloc>() const
+    {
+        return std::basic_string<char, Traits, Alloc>(m_data, m_size);
+    }
+
+    friend bool operator==(string_ref a, string_ref b) noexcept
+    {
+        return a.m_size == b.m_size && (a.m_size == 0 || std::memcmp(a.m_data, b.m_data, a.m_size) == 0);
+    }
+    friend bool operator!=(string_ref a, string_ref b) noexcept
+    {
+        return !(a == b);
+    }
+    friend bool operator<(string_ref a, string_ref b) noexcept
+    {
+        const int c = std::memcmp(a.m_data, b.m_data, (std::min)(a.m_size, b.m_size));
+        return c != 0 ? c < 0 : a.m_size < b.m_size;
+    }
+#ifndef JSON_NO_IO
+    friend std::ostream& operator<<(std::ostream& o, string_ref s)
+    {
+        return o.write(s.m_data, static_cast<std::streamsize>(s.m_size));
+    }
+#endif
+
+  private:
+    const char* m_data = "";
+    std::size_t m_size = 0;
+};
+#endif
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END