Drop the null_result parameter JSON_IMPLEMENT_OPERATOR no longer uses

Without the same-type scalar cases, the macro body has no use for it, and JSON_IMPLEMENT_SCALAR_CASES is now used only by JSON_IMPLEMENT_SCALAR_FAST. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
iter_impl: keep the type-dependent initialization in the constructor
2026-11-02 13:20:40 +00:00 · 2026-11-02 10:05:55 +01:00 · 2026-11-02 10:05:54 +01:00 · 2026-11-02 09:41:01 +01:00 · 2026-11-02 09:41:00 +01:00 · 2026-11-02 05:59:57 +00:00
70 changed files with 2135 additions and 876 deletions
@@ -24,7 +24,7 @@ jobs:
    permissions:
      actions: write

-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest

    steps:
      - name: Harden Runner
@@ -19,7 +19,7 @@ permissions:
 jobs:
  save:
    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@dc2769abcc0fcfbadfc1df54081c1608579ef6b2 # v2.22.2
@@ -16,7 +16,7 @@ concurrency:
 jobs:
  check_docs_links:
    if: github.repository == 'nlohmann/json'
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - name: Harden Runner
@@ -12,7 +12,7 @@ jobs:
  comment:
    # push runs on develop have no PR to comment on (and no "pr" artifact)
    if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event == 'pull_request' }}
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    permissions:
      contents: read
      actions: read
@@ -18,7 +18,7 @@ permissions:

 jobs:
  dependency-review:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@dc2769abcc0fcfbadfc1df54081c1608579ef6b2 # v2.22.2
@@ -24,7 +24,7 @@ on:
 jobs:
  flawfinder:
    name: Flawfinder
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    permissions:
      actions: read
      contents: read
@@ -19,7 +19,7 @@ jobs:
      contents: read
      pull-requests: write

-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest

    steps:
      - name: Harden Runner
@@ -34,7 +34,7 @@ jobs:
      contents: write

    if: github.repository == 'nlohmann/json'
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@dc2769abcc0fcfbadfc1df54081c1608579ef6b2 # v2.22.2
@@ -24,7 +24,7 @@ permissions:
 jobs:
  analysis:
    name: Scorecard analysis
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    permissions:
      # Needed to upload the results to code-scanning dashboard.
      security-events: write
@@ -8,7 +8,7 @@ permissions:

 jobs:
  stale:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest

    permissions:
      issues: write
@@ -18,7 +18,7 @@ concurrency:

 jobs:
  ci_test_gcc:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: gcc:latest
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -130,7 +130,7 @@ jobs:
        run: cmake --build build --target ${{ matrix.target }}

  ci_static_analysis_clang:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: silkeh/clang:22
    strategy:
      matrix:
@@ -149,7 +149,7 @@ jobs:
        run: cmake --build build --target ${{ matrix.target }}

  ci_cmake_options:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: ubuntu:24.04
    strategy:
      matrix:
@@ -209,7 +209,7 @@ jobs:
          fail-on-error: false

  ci_test_compilers_gcc_old:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    strategy:
      matrix:
        compiler: ['4.8', '4.9', '5', '6']
@@ -251,7 +251,7 @@ jobs:
        run: cmake --build build --target ci_test_compiler_g++-${{ matrix.compiler }}

  ci_test_compilers_gcc:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    strategy:
      matrix:
        # older GCC docker images (4, 5, 6) fail to check out code
@@ -269,7 +269,7 @@ jobs:
        run: cmake --build build --target ci_test_compiler_default

  ci_test_compilers_clang:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    strategy:
      matrix:
        compiler: ['3.4', '3.5', '3.6', '3.7', '3.8', '3.9', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15-bullseye', '16', '17', '18', '19', '20', '21', '22', 'latest']
@@ -289,7 +289,7 @@ jobs:
        run: cmake --build build --target ci_test_compiler_default

  ci_test_standards_gcc:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: gcc:latest
    strategy:
      matrix:
@@ -306,7 +306,7 @@ jobs:
        run: cmake --build build --target ci_test_gcc_cxx${{ matrix.standard }}

  ci_test_standards_clang:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: silkeh/clang:latest
    strategy:
      matrix:
@@ -330,7 +330,7 @@ jobs:
        if: ${{ matrix.stdlib == 'libstdcxx' }}

  ci_cuda_example:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
@@ -356,7 +356,7 @@ jobs:
    strategy:
      matrix:
        container: ['gcc:latest', 'silkeh/clang:latest']
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: ${{ matrix.container }}
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -383,7 +383,7 @@ jobs:
        run: cmake --build build --target ci_module_cpp20

  ci_icpc:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    # Intel discontinued the classic icc/icpc compiler in oneAPI 2024.0; this is
    # Intel's own last officially published image that still includes it.
    container: intel/oneapi-hpckit:2023.2.1-devel-ubuntu22.04
@@ -402,7 +402,7 @@ jobs:
        run: cmake --build build --target ci_icpc

  ci_icpx:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: intel/oneapi-hpckit:latest
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -416,7 +416,7 @@ jobs:
        run: cmake --build build --target ci_icpx

  ci_nvhpc:
-    runs-on: ubuntu-26.04
+    runs-on: ubuntu-latest
    container: nvcr.io/nvidia/nvhpc:25.5-devel-cuda12.9-ubuntu22.04
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -348,20 +348,20 @@ add_custom_target(ci_test_no_thread_local

 add_custom_target(ci_test_coverage
    COMMAND CXX=g++ ${CMAKE_COMMAND}
-        -DCMAKE_BUILD_TYPE=Debug -GNinja -DCMAKE_CXX_FLAGS="--coverage;-fprofile-arcs;-ftest-coverage"
+        -DCMAKE_BUILD_TYPE=Debug -GNinja -DCMAKE_CXX_FLAGS="--coverage;-fprofile-arcs;-ftest-coverage;-fvar-tracking-assignments"
        -DJSON_BuildTests=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_coverage
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_coverage
    COMMAND cd ${PROJECT_BINARY_DIR}/build_coverage && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure

    COMMAND CXX=g++ ${CMAKE_COMMAND}
-        -DCMAKE_BUILD_TYPE=Debug -GNinja -DCMAKE_CXX_FLAGS="-m32;--coverage;-fprofile-arcs;-ftest-coverage"
+        -DCMAKE_BUILD_TYPE=Debug -GNinja -DCMAKE_CXX_FLAGS="-m32;--coverage;-fprofile-arcs;-ftest-coverage;-fvar-tracking-assignments"
        -DJSON_BuildTests=ON -DJSON_32bitTest=ONLY
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_coverage32
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_coverage32
    COMMAND cd ${PROJECT_BINARY_DIR}/build_coverage32 && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure

-    COMMAND ${LCOV_TOOL} --directory . --capture --output-file json.info --rc branch_coverage=1 --rc geninfo_unexecuted_blocks=1 --ignore-errors mismatch --ignore-errors unused --ignore-errors inconsistent
+    COMMAND ${LCOV_TOOL} --directory . --capture --output-file json.info --rc branch_coverage=1 --ignore-errors mismatch --ignore-errors unused --ignore-errors inconsistent
    COMMAND ${LCOV_TOOL} -e json.info ${SRC_FILES} --output-file json.info.filtered --rc branch_coverage=1 --ignore-errors unused --ignore-errors inconsistent
    COMMAND ${CMAKE_SOURCE_DIR}/tests/thirdparty/imapdl/filterbr.py json.info.filtered > json.info.filtered.noexcept
    COMMAND ${GENHTML_TOOL} --title "JSON for Modern C++" --legend --demangle-cpp --output-directory html --show-details --branch-coverage --ignore-errors inconsistent json.info.filtered.noexcept
@@ -91,7 +91,7 @@ const typename BasicJsonType::binary_t& binary_value(const BasicJsonType& j)
 }

 template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-typename View::basic_json_type::binary_t binary_value(const View& /*unused*/)
+typename View::basic_json_type::binary_t binary_value(const View& /*unused*/) // LCOV_EXCL_LINE
 {
    return {}; // LCOV_EXCL_LINE
 }
@@ -467,13 +467,11 @@ class binary_reader

            const std::size_t element_type_parse_position = chars_read;
            // an array's elements are named "0", "1", ... in the wire format,
-            // and those names are not passed on: they are skipped, and only
-            // checked if error_handler_t::strict must reject ill-formed UTF-8
+            // and those names are not passed on: they are skipped unless
+            // error_handler_t::strict must reject ill-formed UTF-8 in them
            const bool is_object = container_stack.back().is_object;
            key.clear();
-            if (JSON_HEDLEY_UNLIKELY(!(is_object || error_handler != error_handler_t::strict
-                                       ? get_bson_cstr(key, is_object)
-                                       : check_bson_cstr(key, std::integral_constant<bool, bulk_scan> {}))))
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key, is_object || error_handler == error_handler_t::strict)))
            {
                return false;
            }
@@ -497,7 +495,7 @@ class binary_reader
    @param[in] store  whether the characters are needed; if not (the names of
                      an array's elements), they are skipped and @a result may
                      be left unchanged, and they are not checked against
-                      @ref error_handler (@ref check_bson_cstr checks them)
+                      @ref error_handler
    @return `true` if the \\x00-byte indicating the end of the string was
             encountered before the EOF; false` indicates an unexpected EOF.
    */
@@ -556,42 +554,6 @@ class binary_reader
        return true;
    }

-    /*!
-    @brief skip a C-style string that error_handler_t::strict must check
-
-    The names of an array's elements are not passed on. On contiguous input,
-    a well-formed name is checked in place and skipped without being copied.
-    Otherwise (no \\x00-byte in the input that can be scanned, or ill-formed
-    UTF-8), it is read by @ref get_bson_cstr, which reports the error.
-
-    @param[in,out] result  an empty string, which may receive the name
-    @return whether the name was read and is well-formed
-    */
-    bool check_bson_cstr(string_t& result, std::true_type /*bulk*/)
-    {
-        const std::size_t remaining = ia.bulk_remaining();
-        if (remaining != 0)
-        {
-            const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
-            const std::size_t length = find_zero_byte(data, remaining);
-            if (length != remaining && JSON_HEDLEY_LIKELY(valid_utf8_string(data, length)))
-            {
-                // consume the string and its \x00-byte, as get_bson_cstr does
-                ia.bulk_skip(length + 1);
-                chars_read += length + 1;
-                current = 0x00;
-                return true;
-            }
-        }
-        return get_bson_cstr(result);
-    }
-
-    /// input that is not contiguous: the name is read and checked byte by byte
-    bool check_bson_cstr(string_t& result, std::false_type /*bulk*/)
-    {
-        return get_bson_cstr(result);
-    }
-
    /// input that is not contiguous: C-style strings are read byte by byte
    bool get_bson_cstr_bulk(string_t& /*result*/, const bool /*store*/, std::false_type /*bulk*/) const noexcept
    {
@@ -545,12 +545,9 @@ class input_stream_adapter
    std::char_traits<char>::int_type get_character_slow()
    {
 #if !JSON_DISABLE_STREAM_BULK_SCAN
-        // sbumpc() 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();
-        }
+        // the get area is exhausted (get_character() handles the other case),
+        // so sbumpc() refills it
+        save_token_segment();
 #endif

        auto res = sb->sbumpc();
@@ -563,17 +560,13 @@ class input_stream_adapter
            is->clear(is->rdstate() | std::ios::eofbit);
        }
 #if !JSON_DISABLE_STREAM_BULK_SCAN
-        else if (JSON_HEDLEY_UNLIKELY(refill))
+        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));
        }
-        else
-        {
-            current_in_get_area = true;
-        }
 #endif
        return res;
    }
@@ -999,7 +999,7 @@ class json_sax_dom_parser : public json_sax_dom_error_state
        ordered_data.members[f.ordered.dest_member].second = std::move(value);
    }

-    static void place_member(const frame& /*f*/, BasicJsonType&& /*value*/, std::false_type /*indexed*/) noexcept {}
+    static void place_member(const frame& /*f*/, BasicJsonType&& /*value*/, std::false_type /*indexed*/) noexcept {} // LCOV_EXCL_LINE

    /// store the members of a new object directly in it
    bool start_stored_object(std::size_t len)
@@ -1737,7 +1737,7 @@ class json_sax_dom_callback_parser : public json_sax_dom_error_state
        key_stack.push_back(val);

        // add discarded value at the given key and store the reference for later
-        if (keep && ref_stack.back())
+        if (keep)
        {
            auto& obj = *ref_stack.back()->m_data.m_value.object;
            // a single lookup: insert the placeholder, or find the existing member
@@ -1794,7 +1794,7 @@ class json_sax_dom_callback_parser : public json_sax_dom_error_state

        const string_t object_key = pop_container();

-        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        if (!ref_stack.empty() && ref_stack.back())
        {
            // remove discarded value
            remove_discarded_value(*ref_stack.back(), object_key);
@@ -1960,8 +1960,7 @@ class json_sax_dom_callback_parser : public json_sax_dom_error_state
    */
    string_t current_key() const
    {
-        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object()
-                && !key_stack.empty())
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object())
        {
            return key_stack.back();
        }
@@ -300,14 +300,16 @@ class lexer : public lexer_base<BasicJsonType>
    /// calls would (including the position and token bookkeeping of a
    /// streaming adapter, see bulk_consume) and leaves @a current holding the last of
    /// the 4 digits, just as the last such get() would; the codepoint is
-    /// written to @a out. Makes no state change and returns false for a
-    /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
-    /// being a hex digit, so the caller falls back unchanged to the
-    /// per-character loop, which then reports the same diagnostic (stopping
-    /// at the first invalid digit) as before this optimization.
+    /// written to @a out. Makes no state change and returns false for fewer
+    /// than 4 remaining bytes or any of the 4 bytes not being a hex digit, so
+    /// the caller falls back unchanged to the per-character loop, which then
+    /// reports the same diagnostic (stopping at the first invalid digit) as
+    /// before this optimization.
    bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
    {
-        if (next_unget || ia.bulk_remaining() < 4)
+        // no unget is pending inside a string (see get_after_string_run())
+        JSON_ASSERT(!next_unget);
+        if (ia.bulk_remaining() < 4)
        {
            return false;
        }
@@ -437,11 +439,10 @@ class lexer : public lexer_base<BasicJsonType>
    template<bool Keep>
    char_int_type get_after_string_run(std::true_type /*bulk*/, std::integral_constant<bool, Keep> keep)
    {
-        // a pending unget must be consumed through the normal path first
-        if (next_unget)
-        {
-            return get();
-        }
+        // scan_string() is entered from scan_after_whitespace(), whose current
+        // was read by skip_whitespace() (its first get() clears a pending
+        // unget), and nothing in scan_string() calls unget()
+        JSON_ASSERT(!next_unget);
        const std::size_t remaining = ia.bulk_remaining();
        if (remaining == 0)
        {
@@ -1410,7 +1411,7 @@ scan_number_done:
                return token_type::value_unsigned;
            }
        }
-        else if (number_type == token_type::value_integer)
+        else // value_integer (the callers handle value_float themselves)
        {
            if (parse_integer_signed(first, last, value_integer))
            {
@@ -1516,11 +1517,9 @@ scan_number_done:
    */
    token_type scan_number_bulk_contiguous()
    {
-        // a pending unget offsets the buffer position from current; fall back
-        if (next_unget)
-        {
-            return token_type::uninitialized;
-        }
+        // called right after scan_after_whitespace() read current (see
+        // get_after_string_run()), so no unget is pending
+        JSON_ASSERT(!next_unget);
        const std::size_t rem = ia.bulk_remaining();
        if (rem == 0)
        {
@@ -1541,11 +1540,7 @@ scan_number_done:
        if (data[0] == '-')
        {
            number_type = token_type::value_integer;
-            i = 1;
-            if (i >= avail)
-            {
-                return token_type::uninitialized;
-            }
+            i = 1; // avail >= 2: rem == 0 returned above
        }
        const std::size_t integer_begin = i;
        if (data[i] == '0')
@@ -1787,7 +1782,10 @@ scan_number_done:
    /// the error at the right character
    JSON_HEDLEY_ALWAYS_INLINE bool scan_literal_bulk(const char* rest, const std::size_t length, std::true_type /*bulk*/)
    {
-        if (next_unget || ia.bulk_remaining() < length
+        // called right after scan_after_whitespace() read current (see
+        // get_after_string_run()), so no unget is pending
+        JSON_ASSERT(!next_unget);
+        if (ia.bulk_remaining() < length
                || std::memcmp(ia.bulk_data(), rest, length) != 0)
        {
            return false;
@@ -575,10 +575,7 @@ class parser
    {
        std::string error_msg = "syntax error ";

-        if (!context.empty())
-        {
-            error_msg += concat("while parsing ", context, ' ');
-        }
+        error_msg += concat("while parsing ", context, ' ');

        error_msg += "- ";

@@ -598,7 +595,7 @@ class parser
        }

        return error_msg;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

  private:
    /// callback function
@@ -108,6 +108,9 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
    {
        JSON_ASSERT(m_object != nullptr);

+        // m_it is already value-initialized, so this is not needed for
+        // correctness; it is kept because GCC generates faster loops with it
+        // (iterating a parsed document is 0.5-2.7 % slower without it, #6005)
        if (m_object->is_object())
        {
            m_it.object_iterator = typename object_t::iterator();
@@ -304,7 +304,7 @@ class json_pointer
        result.reference_tokens.insert(result.reference_tokens.end(), lhs.reference_tokens.begin(), lhs.reference_tokens.end());
        result.reference_tokens.insert(result.reference_tokens.end(), rhs.reference_tokens.begin(), rhs.reference_tokens.end());
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
@@ -315,7 +315,7 @@ class json_pointer
        result.reference_tokens.insert(result.reference_tokens.end(), lhs.reference_tokens.begin(), lhs.reference_tokens.end());
        result.reference_tokens.push_back(std::move(token));
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
@@ -2180,7 +2180,7 @@ class json_pointer
                    {
                        // create an entry in the array
                        current = &current->operator[](array_index<BasicJsonType>(token));
-                        break;
+                        break; // LCOV_EXCL_LINE (needs an array index with 10 or more digits: more than 1e9 elements)
                    }

                    /*
@@ -2217,7 +2217,7 @@ class json_pointer
        json_pointer<string_t> result;
        result.reference_tokens = reference_tokens;
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    json_pointer<string_t> convert()&&
    {
@@ -833,7 +833,7 @@ class binary_writer
        while (n != 0);
        std::reverse(result.begin(), result.end());
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /*!
    @brief the decimal digits of the integer @a n, with a leading '-' if it
@@ -860,7 +860,7 @@ class binary_writer
        }
        std::reverse(result.begin(), result.end());
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /*!
    @brief throws because the integer @a j is too large for @a format
@@ -1792,7 +1792,7 @@ class binary_writer
        std::memcpy(out, &n, sizeof(NumberType));
        if (!is_little_endian)
        {
-            std::reverse(out, out + sizeof(NumberType));
+            std::reverse(out, out + sizeof(NumberType)); // LCOV_EXCL_LINE (big-endian hosts only)
        }
    }

@@ -1921,7 +1921,7 @@ class binary_writer
            const string_t& value = *j.m_data.m_value.string;
            if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::int32_t>(value.size() + 1ul)))
            {
-                return false;
+                return false; // LCOV_EXCL_LINE (a string of 2 GiB or more)
            }
            out[0] = to_char_type(0x02);
            store_little_endian<std::int32_t>(p, static_cast<std::int32_t>(value.size() + 1ul));
@@ -2378,7 +2378,7 @@ class binary_writer
        const std::size_t size = oa.written() - pos;
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::int32_t>(size)))
        {
-            return false;
+            return false; // LCOV_EXCL_LINE (a document of 2 GiB or more)
        }
        const auto le_size = static_cast<std::uint32_t>(size);
        oa.overwrite(pos, is_little_endian ? le_size : byteswap(le_size));
@@ -2507,7 +2507,7 @@ class binary_writer
                    {
                        if (JSON_HEDLEY_UNLIKELY(!close_bson_container(nested_size_pos)))
                        {
-                            return false;
+                            return false; // LCOV_EXCL_LINE (a document of 2 GiB or more)
                        }
                        continue;
                    }
@@ -2522,7 +2522,7 @@ class binary_writer

            if (JSON_HEDLEY_UNLIKELY(!close_bson_container(current.size_slot)))
            {
-                return false;
+                return false; // LCOV_EXCL_LINE (a document of 2 GiB or more)
            }
            if (parents.empty())
            {
@@ -2779,10 +2779,10 @@ class binary_writer

    Selected through masks rather than branches, as the type and the sign of
    the values in an array of mixed signs alternate unpredictably (non-negative
-    integers are number_unsigned after parsing). Up to 64 bits, the sign is bit
-    63 of the result (a narrower integer is sign-extended); computing it with
-    masks keeps GCC from branching on the type. A wider integer has to be
-    compared.
+    integers are number_unsigned after parsing). The sign is bit 63 of the
+    result (a narrower integer is sign-extended); computing it with masks keeps
+    GCC from branching on the type. Only called if @ref integers_fit_64_bits();
+    a wider number type is written with range checks on the whole value.
    */
    static std::uint64_t integer_bits(const BasicJsonType& j, std::uint64_t& sign_mask) noexcept
    {
@@ -2790,9 +2790,7 @@ class binary_writer
        const std::uint64_t raw = is_signed
                                  ? static_cast<std::uint64_t>(j.m_data.m_value.number_integer)
                                  : static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned);
-        sign_mask = sizeof(typename BasicJsonType::number_integer_t) <= sizeof(std::uint64_t)
-                    ? (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u))
-                    : std::uint64_t{0} - static_cast<std::uint64_t>(is_signed && j.m_data.m_value.number_integer < 0);
+        sign_mask = (std::uint64_t{0} - static_cast<std::uint64_t>(is_signed)) & (std::uint64_t{0} - (raw >> 63u));
        return raw;
    }

@@ -4159,57 +4157,34 @@ class binary_writer
    }

    /*!
-    @brief validate (dry_run) or write one BJData ND-array element of integer dtype @a T
-    @return whether @a el's value is in range of @a T; always true when @a dry_run is false
-    */
-    template<typename T>
-    bool write_bjdata_ndarray_element(const BasicJsonType& el, const bool dry_run)
-    {
-        if (dry_run)
-        {
-            return bjdata_ndarray_value_in_range<T>(el);
-        }
-        using storage_type = typename std::conditional<std::is_unsigned<T>::value, std::uint64_t, std::int64_t>::type;
-        write_number(static_cast<T>(el.template get<storage_type>()), true);
-        return true;
-    }
-
-    /*!
-    @brief validate (dry_run) or write one BJData ND-array element of dtype 'd' (single precision)
+    @brief whether the BJData ND-array element @a el can be written with dtype 'd' (single precision)
    @return whether @a el's value survives narrowing to float and back without any change
-            (so the ND-array round-trips exactly), or is infinite or NaN; always true when
-            @a dry_run is false
+            (so the ND-array round-trips exactly), or is infinite or NaN
    */
-    bool write_bjdata_ndarray_float_element(const BasicJsonType& el, const bool dry_run)
+    static bool bjdata_ndarray_float_in_range(const BasicJsonType& el) noexcept
    {
        const auto dval = static_cast<double>(el.m_data.m_value.number_float);
-        if (dry_run)
-        {
 #ifdef __GNUC__
-            JSON_HEDLEY_DIAGNOSTIC_PUSH
-            JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
-            // a value that would be rounded (rather than exactly represented) by the
-            // narrowing to float is treated like an out-of-range integer element; this
-            // is the same criterion write_compact_float() uses for CBOR/MessagePack
-            const bool in_range = std::isnan(dval) ||
-                                  (dval >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
-                                   dval <= static_cast<double>((std::numeric_limits<float>::max)()) &&
-                                   static_cast<double>(static_cast<float>(dval)) == dval) ||
-                                  std::isinf(dval);
+        // a value that would be rounded (rather than exactly represented) by the
+        // narrowing to float is treated like an out-of-range integer element; this
+        // is the same criterion write_compact_float() uses for CBOR/MessagePack
+        return std::isnan(dval) ||
+               (dval >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                dval <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(dval)) == dval) ||
+               std::isinf(dval);
 #ifdef __GNUC__
-            JSON_HEDLEY_DIAGNOSTIC_POP
+        JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
-            return in_range;
-        }
-        write_number(static_cast<float>(dval), true);
-        return true;
    }

    /*!
    @brief write the elements of an ND-array as the number kind @a dtype names
           (see @ref write_bjdata_ndarray), after they have been found to be
-           in range by a dry run of @ref write_bjdata_ndarray_elements
+           in range by @ref bjdata_ndarray_elements_in_range

    The elements are encoded in blocks into space reserved from the sink.
    */
@@ -4291,20 +4266,13 @@ class binary_writer
    }

    /*!
-    @brief validate or write every element of a BJData ND-array's `_ArrayData_`
+    @brief whether every element of a BJData ND-array's `_ArrayData_` is in range for its dtype
    @param[in] array_data  the `_ArrayData_` array
    @param[in] dtype       the ND-array dtype marker, as returned by bjdata_ndarray_type_marker()
-    @param[in] dry_run     true to only range-check each element, false to write it
-    @return whether every element is in range for @a dtype (always true when @a dry_run is false)
+    @return whether every element is in range for @a dtype
    */
-    bool write_bjdata_ndarray_elements(const BasicJsonType& array_data, const CharType dtype, const bool dry_run)
+    static bool bjdata_ndarray_elements_in_range(const BasicJsonType& array_data, const CharType dtype)
    {
-        if (!dry_run)
-        {
-            write_bjdata_ndarray_values(array_data, dtype);
-            return true;
-        }
-
        for (const auto& el : array_data)
        {
            bool ok = true;
@@ -4312,43 +4280,39 @@ class binary_writer
            {
                case 'U':
                case 'B':
-                    ok = write_bjdata_ndarray_element<std::uint8_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::uint8_t>(el);
                    break;
                case 'C':
                    // BJData limits a char to 0..127 (the intersection of the int8 and uint8 ranges)
                    ok = bjdata_ndarray_value_in_range<std::int8_t>(el) && bjdata_ndarray_value_in_range<std::uint8_t>(el);
                    break;
                case 'i':
-                    ok = write_bjdata_ndarray_element<std::int8_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::int8_t>(el);
                    break;
                case 'u':
-                    ok = write_bjdata_ndarray_element<std::uint16_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::uint16_t>(el);
                    break;
                case 'I':
-                    ok = write_bjdata_ndarray_element<std::int16_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::int16_t>(el);
                    break;
                case 'm':
-                    ok = write_bjdata_ndarray_element<std::uint32_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::uint32_t>(el);
                    break;
                case 'l':
-                    ok = write_bjdata_ndarray_element<std::int32_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::int32_t>(el);
                    break;
                case 'M':
-                    ok = write_bjdata_ndarray_element<std::uint64_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::uint64_t>(el);
                    break;
                case 'L':
-                    ok = write_bjdata_ndarray_element<std::int64_t>(el, dry_run);
+                    ok = bjdata_ndarray_value_in_range<std::int64_t>(el);
                    break;
                case 'd':
-                    ok = write_bjdata_ndarray_float_element(el, dry_run);
+                    ok = bjdata_ndarray_float_in_range(el);
                    break;
                case 'D':
                default:
                    // 'D' (double) already spans the full range of number_float_t
-                    if (!dry_run)
-                    {
-                        write_number(el.template get<double>(), true);
-                    }
                    break;
            }
            if (!ok)
@@ -4435,7 +4399,7 @@ class binary_writer
            const auto dim = el.template get<std::uint64_t>();
            if (!value_in_range_of<std::size_t>(dim))
            {
-                return true;
+                return true; // LCOV_EXCL_LINE (size_t is narrower than 64 bits)
            }
            const auto dim_size = static_cast<std::size_t>(dim);

@@ -4485,7 +4449,7 @@ class binary_writer
        // wrap (integers) or overflow to infinity (the "single" precision
        // float) instead of being reported, so such an object falls back to
        // a plain object encoding as well
-        if (!write_bjdata_ndarray_elements(array_data, dtype, true))
+        if (!bjdata_ndarray_elements_in_range(array_data, dtype))
        {
            return true;
        }
@@ -4497,7 +4461,7 @@ class binary_writer

        write_ubjson(array_size, use_count, use_type, true,  true, bjdata_version);

-        write_bjdata_ndarray_elements(array_data, dtype, false);
+        write_bjdata_ndarray_values(array_data, dtype);
        return false;
    }

@@ -4823,8 +4787,8 @@ class binary_writer
    run are encoded into space reserved from the sink, as in
    @ref write_array_elements; an integer that BON8 cannot write (an unsigned
    one above the int64 range, or one of a number type wider than 64 bits) throws
-    from write_bon8_value, like any other value that is not a number. Kept out
-    of line, like @ref write_cbor_array.
+    out_of_range.407, as write_bon8_value does. Kept out of line, like
+    @ref write_cbor_array.
    */
    template<typename ArrayType>
    JSON_HEDLEY_NEVER_INLINE
@@ -4874,10 +4838,10 @@ class binary_writer
                string_open = false;
            }

-            if (unencodable)
+            if (JSON_HEDLEY_UNLIKELY(unencodable))
            {
-                write_bon8_value(*it, string_open, depth + 1);
-                ++it;
+                // an integer beyond the int64 range, as write_bon8_value would report it
+                throw_integer_out_of_range(*it, input_format_t::bon8, "int64");
            }
        }
    }
@@ -4912,14 +4876,13 @@ class binary_writer
                    break;

                case value_t::number_integer:
-                    if (JSON_HEDLEY_LIKELY(integer_fits<std::int64_t>(value.m_data.m_value.number_integer)))
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits<std::int64_t>(value.m_data.m_value.number_integer)))
                    {
-                        write_bon8_integer(static_cast<std::int64_t>(value.m_data.m_value.number_integer));
-                        string_open = false;
-                        break;
+                        // beyond 64 bits (number types wider than that)
+                        throw_integer_out_of_range(value, input_format_t::bon8, "int64");
                    }
-                    // beyond 64 bits (number types wider than that): throws
-                    write_bon8_value(value, string_open, depth + 1);
+                    write_bon8_integer(static_cast<std::int64_t>(value.m_data.m_value.number_integer));
+                    string_open = false;
                    break;

                case value_t::number_float:
@@ -4928,14 +4891,13 @@ class binary_writer
                    break;

                case value_t::number_unsigned:
-                    if (JSON_HEDLEY_LIKELY(integer_fits_max<std::int64_t>(value.m_data.m_value.number_unsigned)))
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::int64_t>(value.m_data.m_value.number_unsigned)))
                    {
-                        write_bon8_integer(static_cast<std::int64_t>(value.m_data.m_value.number_unsigned));
-                        string_open = false;
-                        break;
+                        // too large for BON8
+                        throw_integer_out_of_range(value, input_format_t::bon8, "int64");
                    }
-                    // too large for BON8: throws
-                    write_bon8_value(value, string_open, depth + 1);
+                    write_bon8_integer(static_cast<std::int64_t>(value.m_data.m_value.number_unsigned));
+                    string_open = false;
                    break;

                case value_t::object:
@@ -1113,36 +1113,21 @@ class serializer
                {
                    // the code point is at least 0x60 (smaller ones are handled
                    // above) and is not printable ASCII (which the scanner
-                    // copies): it is DEL (0x7F) under EnsureAscii or a non-ASCII
-                    // character
+                    // copies). Under EnsureAscii it is DEL (0x7F): every
+                    // well-formed multi-byte character is escaped by
+                    // write_u_escapes() above, so decode() only ever accepts a
+                    // single byte here, and nothing of it was buffered
                    if (EnsureAscii)
                    {
-                        JSON_ASSERT(codepoint >= 0x7F);
-                        if (error_handler == error_handler_t::keep)
-                        {
-                            // this character was buffered as raw bytes below
-                            // in case it turned out to be part of an
-                            // ill-formed sequence (which is kept as is); now
-                            // that it decoded to a well-formed code point,
-                            // undo that and \u-escape it like any other
-                            // character instead
-                            bytes = bytes_after_last_accept;
-                        }
-                        if (codepoint <= 0xFFFF)
-                        {
-                            write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
-                        }
-                        else
-                        {
-                            write_u_escape(bytes, static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)));
-                            write_u_escape(bytes, static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
-                        }
+                        JSON_ASSERT(codepoint == 0x7F);
+                        JSON_ASSERT(bytes == bytes_after_last_accept);
+                        write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
                    }
                    else
                    {
                        // copy byte to buffer (all previous bytes of the
                        // sequence have been copied in the default case below)
-                        string_buffer[bytes++] = s[i];
+                        string_buffer[bytes++] = s[i]; // LCOV_EXCL_LINE (well-formed sequences are copied in runs)
                    }

                    reserve_string_buffer(bytes);
@@ -139,7 +139,7 @@ inline OutStringType concat(Args && ... args)
    str.reserve(concat_length(args...));
    concat_into(str, std::forward<Args>(args)...);
    return str;
-}
+} // LCOV_EXCL_LINE (exception cleanup only)

 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -83,10 +83,6 @@ template<typename StringType>
 inline void unescape(StringType& s)
 {
    auto pos = s.find_first_of('~', 0);
-    if (pos == StringType::npos)
-    {
-        return;
-    }

    StringType result;
    result.reserve(s.size());
@@ -36,7 +36,7 @@ StringType to_string(std::size_t value)
    StringType result;
    int_to_string(result, value);
    return result;
-}
+} // LCOV_EXCL_LINE (exception cleanup only)

 /// @return a byte as two uppercase hexadecimal digits
 inline std::string hex_byte(const std::uint8_t byte)
@@ -46,7 +46,7 @@ inline std::string hex_byte(const std::uint8_t byte)
    result[0] = nibble_to_hex[byte / 16];
    result[1] = nibble_to_hex[byte % 16];
    return result;
-}
+} // LCOV_EXCL_LINE (exception cleanup only)

 /*!
@brief write a UTF-16 code unit as four lowercase hexadecimal digits
@@ -390,7 +390,7 @@ inline StringType sanitize_utf8(const StringType& s, const error_handler_t error
    }

    return result;
-}
+} // LCOV_EXCL_LINE (exception cleanup only)

 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -428,28 +428,19 @@ class view_side
        return string_view_t(m_view.m_doc->str(*m_view.m_node), m_view.m_node->len);
    }

-    /// a number, boolean, or null as a basic_json value (no allocation)
+    /// a number as a basic_json value (no allocation); only called for numbers
    BasicJsonType scalar() const
    {
-        switch (m_view.type())
+        const value_t t = m_view.type();
+        if (t == value_t::number_integer)
        {
-            case value_t::number_integer:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_integer_t>());
-            case value_t::number_unsigned:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_unsigned_t>());
-            case value_t::number_float:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_float_t>());
-            case value_t::boolean:
-                return BasicJsonType(m_view.template get<bool>());
-            case value_t::null:
-            case value_t::object:
-            case value_t::array:
-            case value_t::string:
-            case value_t::binary:
-            case value_t::discarded:
-            default:
-                return BasicJsonType(nullptr);
+            return BasicJsonType(m_view.template get<typename BasicJsonType::number_integer_t>());
        }
+        if (t == value_t::number_unsigned)
+        {
+            return BasicJsonType(m_view.template get<typename BasicJsonType::number_unsigned_t>());
+        }
+        return BasicJsonType(m_view.template get<typename BasicJsonType::number_float_t>());
    }

    /// start at the first element of this array
@@ -96,11 +96,11 @@ NLOHMANN_VIEW_NOINLINE inline void check_utf8_scan(const unsigned char* p, std::
        }
        if (*q >= 0x80)
        {
-            check_utf8_bytewise(p, n, static_cast<std::size_t>(q - p));
-            return; // not reached: the scan stopped at ill-formed UTF-8
+            break; // ill-formed UTF-8: reported below
        }
        ++q; // a quote, backslash, or control character
    }
+    check_utf8_bytewise(p, n, static_cast<std::size_t>(q - p));
 }

 inline void check_utf8(const char* s, std::size_t n)
@@ -243,7 +243,7 @@ inline node* find_parent(const document_data& d, const node* target)
    }
    if (target == lo)
    {
-        return nullptr;
+        return nullptr; // LCOV_EXCL_LINE (the root, or a new value's root, which is linked)
    }
    for (;;)
    {
@@ -420,10 +420,12 @@ struct throwing_sax
        return true;
    }

+    // LCOV_EXCL_START (throw_parse_failure parses JSON only)
    bool binary(binary_t& /*unused*/)
    {
        return true;
    }
+    // LCOV_EXCL_STOP

    bool start_object(std::size_t /*unused*/)
    {
@@ -65,14 +65,9 @@ struct position_source
        return token{end - start};
    }

-    /// the range [first, last), or none if either is npos
+    /// the range [first, last)
    void set(std::size_t first, std::size_t last) noexcept
    {
-        if (first == std::string::npos || last == std::string::npos)
-        {
-            clear();
-            return;
-        }
        start = first;
        end = last;
    }
@@ -191,11 +186,11 @@ struct position_source
                first = n.off;
                last = n.off + 4u;
                break;
-            case node_kind::object:
+            case node_kind::object: // LCOV_EXCL_LINE
            case node_kind::array:
            case node_kind::link:
            default:
-                break;
+                break; // LCOV_EXCL_LINE
        }
        // (a crafted image can point past the text)
        if (last == std::string::npos || last > d.size)
@@ -1389,20 +1389,10 @@ class view_serializer
    /// a float node as dump() writes it
    void write_float_node(const node& n)
    {
-        write_float_node(n, fast_double {});
-    }
-
-    void write_float_node(const node& n, std::false_type /*other*/)
-    {
+        // (only for types other than double: doubles go through write_double_ahead())
        write_float(float_value<number_float_t>(m_doc, n));
    }

-    void write_float_node(const node& n, std::true_type /*double*/)
-    {
-        m_out.reserve(64);
-        m_out.set_cursor(write_double_at(m_out.cursor(), n));
-    }
-
    /*!
    @brief (doubles) the float at n as dump() writes it, at w (64 bytes of room)

@@ -1497,7 +1487,7 @@ class view_serializer
    {
        const string_t dumped = BasicJsonType(string_t(reinterpret_cast<const char*>(s), n)).dump(); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        static_cast<void>(dumped);
-    }
+    } // LCOV_EXCL_LINE (dump() throws: the callers pass only ill-formed UTF-8)

    template<bool EnsureAscii>
    void write_codepoint(std::uint32_t codepoint, const unsigned char* bytes, std::size_t len)
@@ -1530,15 +1520,7 @@ class view_serializer
        }
        if (codepoint <= 0x1F || (EnsureAscii && codepoint >= 0x7F))
        {
-            if (codepoint <= 0xFFFF)
-            {
-                write_u_escape(codepoint);
-            }
-            else
-            {
-                write_u_escape(0xD7C0u + (codepoint >> 10u));
-                write_u_escape(0xDC00u + (codepoint & 0x3FFu));
-            }
+            write_u_escape(codepoint); // (a single byte: the only caller passes s[i])
            return;
        }
        m_out.put(reinterpret_cast<const char*>(bytes), len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast) LCOV_EXCL_LINE (printable characters are copied in runs)
@@ -400,7 +400,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
 #elif defined(__GNUC__) || defined(__GNUG__)
        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat<string_t>(
-                    detail::to_string<string_t>(static_cast<std::size_t>(__GNUC__)), '.',
+                    detail::to_string<string_t>(static_cast<std::size_t>(__GNUC__)), '.', // LCOV_EXCL_LINE
                    detail::to_string<string_t>(static_cast<std::size_t>(__GNUC_MINOR__)), '.',
                    detail::to_string<string_t>(static_cast<std::size_t>(__GNUC_PATCHLEVEL__)))
            }
@@ -543,10 +543,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    ////////////////////////

  JSON_PRIVATE_UNLESS_TESTED:
-    // the type and value of a basic_json without its base class (defined
-    // below); the destruction helpers of json_value use it as a stand-in
-    struct data;
-
    /*!
    @brief a JSON value

@@ -676,14 +672,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                case value_t::binary:
                    binary = create<binary_t>();
                    break;
-                case value_t::null:
+                case value_t::null: // LCOV_EXCL_LINE
                case value_t::boolean:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::number_float:
                case value_t::discarded:
                default:
-                    break;
+                    break; // LCOV_EXCL_LINE
            }
        }

@@ -723,28 +719,27 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        explicit json_value(array_t* value) noexcept : array(value) {}

 private:
-        // raw, allocation-free transfer of the type and value from src to
-        // dst: no set_parents()/assert_invariant() (the former is
-        // O(#children) per call under JSON_DIAGNOSTICS, which would make the
-        // walk below quadratic); dst takes ownership, src is left as
-        // value_t::null.
-        static void take(data& dst, data& src) noexcept
+        // raw, allocation-free transfer of m_data from src to dst: no
+        // set_parents()/assert_invariant() (the former is O(#children) per
+        // call under JSON_DIAGNOSTICS, which would make the walk below
+        // quadratic); dst takes ownership, src is left as value_t::null.
+        static void take(basic_json& dst, basic_json& src) noexcept
        {
-            dst.m_type = src.m_type;
-            dst.m_value = src.m_value;
-            src.m_type = value_t::null;
+            dst.m_data.m_type = src.m_data.m_type;
+            dst.m_data.m_value = src.m_data.m_value;
+            src.m_data.m_type = value_t::null;
        }

        // true if v is not an array/object, or is an already-empty one
-        static bool has_no_children(const data& v) noexcept
+        static bool has_no_children(const basic_json& v) noexcept
        {
-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
-                return v.m_value.array->empty();
+                return v.m_data.m_value.array->empty();
            }
-            if (v.m_type == value_t::object)
+            if (v.m_data.m_type == value_t::object)
            {
-                return v.m_value.object->empty();
+                return v.m_data.m_value.object->empty();
            }
            return true;
        }
@@ -753,21 +748,21 @@ private:
        // its own, i.e. v can be freed in one go (its destructor then
        // destroys scalars and empty containers only, so it recurses at most
        // one level deep); stops at the first structured child it meets
-        static bool all_children_leaves(const data& v) noexcept
+        static bool all_children_leaves(const basic_json& v) noexcept
        {
            // array_t only needs forward iterators (see custom_array_type)
-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
-                const auto& a = *v.m_value.array;
+                const auto& a = *v.m_data.m_value.array;
                return std::all_of(a.begin(), a.end(), [](const basic_json & el)
                {
-                    return has_no_children(el.m_data);
+                    return has_no_children(el);
                });
            }
-            const auto& o = *v.m_value.object;
+            const auto& o = *v.m_data.m_value.object;
            return std::all_of(o.begin(), o.end(), [](const typename object_t::value_type & el)
            {
-                return has_no_children(el.second.m_data);
+                return has_no_children(el.second);
            });
        }

@@ -799,30 +794,30 @@ private:

        // the child of a non-empty array/object v that the walk in
        // destroy_container() continues with (see walk_child_it() above)
-        static data& walk_child(data& v)
+        static basic_json& walk_child(basic_json& v)
        {
-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
-                return v.m_value.array->back().m_data;
+                return v.m_data.m_value.array->back();
            }
-            JSON_ASSERT(v.m_type == value_t::object);
-            return walk_child_it(*v.m_value.object)->second.m_data;
+            JSON_ASSERT(v.m_data.m_type == value_t::object);
+            return walk_child_it(*v.m_data.m_value.object)->second;
        }

        // removes walk_child(v) from a non-empty array/object v; this never
        // allocates, and since it is only ever called when that child is a
        // scalar or an already-empty array/object, destroying it never
        // recurses more than one level deep (see destroy() below)
-        static void pop_walk_child(data& v)
+        static void pop_walk_child(basic_json& v)
        {
-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
-                v.m_value.array->pop_back();
+                v.m_data.m_value.array->pop_back();
            }
            else
            {
-                JSON_ASSERT(v.m_type == value_t::object);
-                v.m_value.object->erase(walk_child_it(*v.m_value.object));
+                JSON_ASSERT(v.m_data.m_type == value_t::object);
+                v.m_data.m_value.object->erase(walk_child_it(*v.m_data.m_value.object));
            }
        }

@@ -831,23 +826,23 @@ private:
        // recurses at most one level deep); this is the same allocator-based
        // free the old recursive implementation used, just factored out so
        // every level of the walk in destroy() can share it
-        static void free_container(data& v) noexcept
+        static void free_container(basic_json& v) noexcept
        {
            JSON_ASSERT(has_no_children(v) || all_children_leaves(v));
-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
                AllocatorType<array_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_value.array);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_value.array, 1);
+                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.array);
+                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.array, 1);
            }
            else
            {
-                JSON_ASSERT(v.m_type == value_t::object);
+                JSON_ASSERT(v.m_data.m_type == value_t::object);
                AllocatorType<object_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_value.object);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_value.object, 1);
+                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.object);
+                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.object, 1);
            }
-            v.m_type = value_t::null; // avoid a double free if v is later destructed
+            v.m_data.m_type = value_t::null; // avoid a double free if v is later destructed
        }

 public:
@@ -878,16 +873,14 @@ public:

            // This json_value is not itself a basic_json, so the top-level
            // container is first moved into a local stand-in ("cur"); a
-            // default-constructed data has a null pointer in its m_value
-            // (see data::m_value's initializer), so swapping it with *this
-            // leaves this union's own pointer null, and it is never looked
-            // at or freed a second time. The stand-ins are data, not
-            // basic_json, so that destroying a value never constructs a
-            // CustomBaseClass, whose constructor may allocate (#5995).
-            data cur;
-            cur.m_type = t;
+            // default-constructed basic_json has a null pointer in its
+            // m_value (see data::m_value's initializer), so swapping it
+            // with *this leaves this union's own pointer null, and it is
+            // never looked at or freed a second time.
+            basic_json cur;
+            cur.m_data.m_type = t;
            using std::swap;
-            swap(cur.m_value, *this);
+            swap(cur.m_data.m_value, *this);

            destroy_bounded(cur, 0);
        }
@@ -896,7 +889,7 @@ public:
        // The first recursion_depth_limit() levels are destroyed by plain
        // recursion, which is the fastest way and cannot throw; anything
        // nested deeper is handed to destroy_walk(), which uses no call stack.
-        static void destroy_bounded(data& v, std::size_t depth) noexcept
+        static void destroy_bounded(basic_json& v, std::size_t depth) noexcept
        {
            if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
            {
@@ -904,23 +897,23 @@ public:
                return;
            }

-            if (v.m_type == value_t::array)
+            if (v.m_data.m_type == value_t::array)
            {
-                for (auto& child : *v.m_value.array)
+                for (auto& child : *v.m_data.m_value.array)
                {
                    if (child.m_data.m_type == value_t::array || child.m_data.m_type == value_t::object)
                    {
-                        destroy_bounded(child.m_data, depth + 1);
+                        destroy_bounded(child, depth + 1);
                    }
                }
            }
            else
            {
-                for (auto& child : *v.m_value.object)
+                for (auto& child : *v.m_data.m_value.object)
                {
                    if (child.second.m_data.m_type == value_t::array || child.second.m_data.m_type == value_t::object)
                    {
-                        destroy_bounded(child.second.m_data, depth + 1);
+                        destroy_bounded(child.second, depth + 1);
                    }
                }
            }
@@ -947,15 +940,18 @@ public:
        // array/object, which neither allocates nor recurses more
        // than one level deep.
        //
-        // Like destroy_container(), the walk keeps the containers it
-        // holds in data stand-ins (cur, prev, gp, tmp), which never
-        // construct a CustomBaseClass.
-        static void destroy_walk(data& top) noexcept
+        // This json_value is not itself a basic_json, so the
+        // top-level container is first moved into a local stand-in
+        // ("cur"); a default-constructed basic_json has a null
+        // pointer in its m_value (see data::m_value's initializer),
+        // so swapping it with *this leaves this union's own pointer
+        // null, and it is never looked at or freed a second time.
+        static void destroy_walk(basic_json& top) noexcept
        {
-            data cur;
+            basic_json cur;
            take(cur, top);

-            data prev; // value_t::null: no parent
+            basic_json prev; // value_t::null: no parent

            // true right after cur was entered: its children have not been
            // looked at yet. If none of them has children of its own, cur is
@@ -969,7 +965,7 @@ public:
                fresh = false;
                if (has_no_children(cur) || (fresh_now && all_children_leaves(cur)))
                {
-                    if (prev.m_type == value_t::null)
+                    if (prev.m_data.m_type == value_t::null)
                    {
                        free_container(cur);
                        return; // back at the top with nothing left to do
@@ -978,7 +974,7 @@ public:
                    // ascend: detach the grandparent link from prev's
                    // walk_child() slot, drop that (now null) slot, free cur
                    // (it is empty), then move up one level
-                    data gp;
+                    basic_json gp;
                    take(gp, walk_child(prev));
                    pop_walk_child(prev);

@@ -989,7 +985,7 @@ public:
                    continue;
                }

-                data& cur_child_ref = walk_child(cur);
+                basic_json& cur_child_ref = walk_child(cur);

                if (has_no_children(cur_child_ref))
                {
@@ -1001,7 +997,7 @@ public:
                // descend into the non-empty child, reversing the
                // link: its slot takes over prev, and the child becomes
                // the new cur
-                data tmp;
+                basic_json tmp;
                take(tmp, cur_child_ref);
                take(cur_child_ref, prev);
                take(prev, cur);
@@ -1038,14 +1034,14 @@ public:
                    destroy_container(t);
                    break;

-                case value_t::null:
+                case value_t::null: // LCOV_EXCL_LINE
                case value_t::boolean:
                case value_t::number_integer:
                case value_t::number_unsigned:
                case value_t::number_float:
                case value_t::discarded:
                default:
-                    break;
+                    break; // LCOV_EXCL_LINE
            }
        }
    };
@@ -1218,9 +1214,9 @@ public:
        return is_array() ? array_capacity() : object_capacity();
    }
 #else
-    static constexpr std::size_t container_capacity() noexcept
+    static constexpr std::size_t container_capacity() noexcept // LCOV_EXCL_LINE
    {
-        return detail::unknown_size();
+        return detail::unknown_size(); // LCOV_EXCL_LINE
    }
 #endif

@@ -1406,7 +1402,7 @@ public:
    ///       into this switch is worth a few percent when copying a value made
    ///       mostly of numbers
    JSON_HEDLEY_ALWAYS_INLINE
-    static void copy_leaf_value(const basic_json& src, basic_json& dst)
+    static void copy_leaf_value(const basic_json& src, basic_json& dst) // LCOV_EXCL_LINE
    {
        switch (src.m_data.m_type)
        {
@@ -1580,7 +1576,7 @@ public:
        auto src_it = src_object.cbegin();
        for (auto& element : *dst.m_data.m_value.object)
        {
-            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && copy_keys_equal(src_it->first, element.first)))
+            if (JSON_HEDLEY_LIKELY(copy_keys_equal(src_it->first, element.first)))
            {
                copy_shallow(src_it->second, element.second, worklist);
                ++src_it;
@@ -5357,8 +5353,7 @@ public:
    /// @name lexicographical comparison operators
    /// @{

-    // the same-type cases for non-owning scalars, shared by JSON_IMPLEMENT_OPERATOR
-    // and JSON_IMPLEMENT_SCALAR_FAST
+    // the same-type cases for non-owning scalars, used by JSON_IMPLEMENT_SCALAR_FAST
 #define JSON_IMPLEMENT_SCALAR_CASES(op, null_result)                                                     \
  case value_t::null:                                                                                  \
        return (null_result);                                                                            \
@@ -5380,7 +5375,7 @@ public:
    // because any negative signed value is smaller than any unsigned value.
    // Otherwise, the non-negative signed value is cast to unsigned before the
    // comparison to avoid wraparound.
-#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result, deep_result, may_descend) \
+#define JSON_IMPLEMENT_OPERATOR(op, unordered_result, default_result, deep_result, may_descend)          \
    const auto lhs_type = lhs.type();                                                                    \
    const auto rhs_type = rhs.type();                                                                    \
    \
@@ -5408,8 +5403,15 @@ public:
                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
            }                                                                                            \
            \
-            JSON_IMPLEMENT_SCALAR_CASES(op, null_result)                                                 \
-            \
+                /* same-type scalars never get here: the inline fast path of the operator handles them */ \
+            case value_t::null:                                                                          \
+            case value_t::boolean:                                                                       \
+            case value_t::number_integer:                                                                \
+            case value_t::number_unsigned:                                                               \
+            case value_t::number_float:                                                                  \
+                JSON_ASSERT(false); /* NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) */ \
+                return (unordered_result);                                                               \
+                \
            case value_t::string:                                                                        \
                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
                \
@@ -5449,7 +5451,7 @@ public:
               ? (number_integer_t(-1) op number_integer_t(1))                                           \
               : (static_cast<number_unsigned_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_unsigned); \
    }                                                                                             \
-    else if(compares_unordered(lhs, rhs))\
+    else if(lhs_type == value_t::discarded || rhs_type == value_t::discarded)\
    {\
        return (unordered_result);\
    }\
@@ -5517,7 +5519,7 @@ public:
        JSON_HEDLEY_DIAGNOSTIC_PUSH
        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
+        JSON_IMPLEMENT_OPERATOR( ==, false, false,
                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
 #ifdef __GNUC__
        JSON_HEDLEY_DIAGNOSTIC_POP
@@ -5531,7 +5533,6 @@ public:
        // default_result is used if we cannot compare values. In that case,
        // we compare types.
        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
-                                std::partial_ordering::equivalent,
                                std::partial_ordering::unordered,
                                lhs_type <=> rhs_type, // *NOPAD*
                                to_partial_ordering(compare_iteratively<true>(lhs, rhs, false)), true)
@@ -5543,7 +5544,7 @@ public:
        // default_result is used if we cannot compare values. In that case,
        // we compare types. Note we have to call the operator explicitly,
        // because MSVC has problems otherwise.
-        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type),
+        JSON_IMPLEMENT_OPERATOR( <, false, operator<(lhs_type, rhs_type),
                                 compare_iteratively<true>(lhs, rhs, true) == compare_result::less, false)
    }
 #endif
@@ -5558,7 +5559,7 @@ public:
    ///       their inlined code at each call site small. Binary values are
    ///       rare and left to equal_general().
    JSON_HEDLEY_ALWAYS_INLINE
-    static int equal_leaf(const_reference lhs, const_reference rhs) noexcept
+    static int equal_leaf(const_reference lhs, const_reference rhs) noexcept // LCOV_EXCL_LINE
    {
 #ifdef __GNUC__
        JSON_HEDLEY_DIAGNOSTIC_PUSH
@@ -6867,7 +6868,7 @@ public:
        basic_json result(value_t::object);
        json_pointer::flatten("", *this, result);
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /// @brief unflatten a previously flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
@@ -7580,7 +7581,7 @@ public:
        result.append(path.data(), path.size());
        diff_append_key(result, key);
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /// @brief the path of the element @a index of the value at @a path
    static string_t diff_index_path(const string_t& path, const std::size_t index)
@@ -7590,7 +7591,7 @@ public:
        result.append(path.data(), path.size());
        diff_append_index(result, index);
        return result;
-    }
+    } // LCOV_EXCL_LINE (exception cleanup only)

    /// @brief append the "remove" operations for the elements of array
    ///        @a source from @a index on, and the "add" operations for the
@@ -7750,7 +7751,7 @@ public:
        // operations
        if (source == target)
        {
-            return false;
+            return false; // LCOV_EXCL_LINE (equal objects with the same members in the same order return early)
        }

        // slow path: the common keys are in a different relative
@@ -1705,9 +1705,11 @@ class basic_json_document
        {
            // (as before: the library's adapter decides what a null stream yields)
            detail::view::append_adapter(buf, detail::input_adapter(file));
-            return;
        }
-        detail::view::append_file(buf, file);
+        else
+        {
+            detail::view::append_file(buf, file);
+        }
    }
 #endif

@@ -3580,28 +3580,19 @@ class view_side
        return string_view_t(m_view.m_doc->str(*m_view.m_node), m_view.m_node->len);
    }

-    /// a number, boolean, or null as a basic_json value (no allocation)
+    /// a number as a basic_json value (no allocation); only called for numbers
    BasicJsonType scalar() const
    {
-        switch (m_view.type())
+        const value_t t = m_view.type();
+        if (t == value_t::number_integer)
        {
-            case value_t::number_integer:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_integer_t>());
-            case value_t::number_unsigned:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_unsigned_t>());
-            case value_t::number_float:
-                return BasicJsonType(m_view.template get<typename BasicJsonType::number_float_t>());
-            case value_t::boolean:
-                return BasicJsonType(m_view.template get<bool>());
-            case value_t::null:
-            case value_t::object:
-            case value_t::array:
-            case value_t::string:
-            case value_t::binary:
-            case value_t::discarded:
-            default:
-                return BasicJsonType(nullptr);
+            return BasicJsonType(m_view.template get<typename BasicJsonType::number_integer_t>());
        }
+        if (t == value_t::number_unsigned)
+        {
+            return BasicJsonType(m_view.template get<typename BasicJsonType::number_unsigned_t>());
+        }
+        return BasicJsonType(m_view.template get<typename BasicJsonType::number_float_t>());
    }

    /// start at the first element of this array
@@ -4478,14 +4469,9 @@ struct position_source
        return token{end - start};
    }

-    /// the range [first, last), or none if either is npos
+    /// the range [first, last)
    void set(std::size_t first, std::size_t last) noexcept
    {
-        if (first == std::string::npos || last == std::string::npos)
-        {
-            clear();
-            return;
-        }
        start = first;
        end = last;
    }
@@ -4604,11 +4590,11 @@ struct position_source
                first = n.off;
                last = n.off + 4u;
                break;
-            case node_kind::object:
+            case node_kind::object: // LCOV_EXCL_LINE
            case node_kind::array:
            case node_kind::link:
            default:
-                break;
+                break; // LCOV_EXCL_LINE
        }
        // (a crafted image can point past the text)
        if (last == std::string::npos || last > d.size)
@@ -5262,10 +5248,12 @@ struct throwing_sax
        return true;
    }

+    // LCOV_EXCL_START (throw_parse_failure parses JSON only)
    bool binary(binary_t& /*unused*/)
    {
        return true;
    }
+    // LCOV_EXCL_STOP

    bool start_object(std::size_t /*unused*/)
    {
@@ -5573,7 +5561,7 @@ inline node* find_parent(const document_data& d, const node* target)
    }
    if (target == lo)
    {
-        return nullptr;
+        return nullptr; // LCOV_EXCL_LINE (the root, or a new value's root, which is linked)
    }
    for (;;)
    {
@@ -6194,11 +6182,11 @@ NLOHMANN_VIEW_NOINLINE inline void check_utf8_scan(const unsigned char* p, std::
        }
        if (*q >= 0x80)
        {
-            check_utf8_bytewise(p, n, static_cast<std::size_t>(q - p));
-            return; // not reached: the scan stopped at ill-formed UTF-8
+            break; // ill-formed UTF-8: reported below
        }
        ++q; // a quote, backslash, or control character
    }
+    check_utf8_bytewise(p, n, static_cast<std::size_t>(q - p));
 }

 inline void check_utf8(const char* s, std::size_t n)
@@ -9853,20 +9841,10 @@ class view_serializer
    /// a float node as dump() writes it
    void write_float_node(const node& n)
    {
-        write_float_node(n, fast_double {});
-    }
-
-    void write_float_node(const node& n, std::false_type /*other*/)
-    {
+        // (only for types other than double: doubles go through write_double_ahead())
        write_float(float_value<number_float_t>(m_doc, n));
    }

-    void write_float_node(const node& n, std::true_type /*double*/)
-    {
-        m_out.reserve(64);
-        m_out.set_cursor(write_double_at(m_out.cursor(), n));
-    }
-
    /*!
    @brief (doubles) the float at n as dump() writes it, at w (64 bytes of room)

@@ -9961,7 +9939,7 @@ class view_serializer
    {
        const string_t dumped = BasicJsonType(string_t(reinterpret_cast<const char*>(s), n)).dump(); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        static_cast<void>(dumped);
-    }
+    } // LCOV_EXCL_LINE (dump() throws: the callers pass only ill-formed UTF-8)

    template<bool EnsureAscii>
    void write_codepoint(std::uint32_t codepoint, const unsigned char* bytes, std::size_t len)
@@ -9994,15 +9972,7 @@ class view_serializer
        }
        if (codepoint <= 0x1F || (EnsureAscii && codepoint >= 0x7F))
        {
-            if (codepoint <= 0xFFFF)
-            {
-                write_u_escape(codepoint);
-            }
-            else
-            {
-                write_u_escape(0xD7C0u + (codepoint >> 10u));
-                write_u_escape(0xDC00u + (codepoint & 0x3FFu));
-            }
+            write_u_escape(codepoint); // (a single byte: the only caller passes s[i])
            return;
        }
        m_out.put(reinterpret_cast<const char*>(bytes), len); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast) LCOV_EXCL_LINE (printable characters are copied in runs)
@@ -11799,9 +11769,11 @@ class basic_json_document
        {
            // (as before: the library's adapter decides what a null stream yields)
            detail::view::append_adapter(buf, detail::input_adapter(file));
-            return;
        }
-        detail::view::append_file(buf, file);
+        else
+        {
+            detail::view::append_file(buf, file);
+        }
    }
 #endif

@@ -14,7 +14,9 @@ using nlohmann::json;
 #include <array>
 #include <cstdint>
 #include <limits>
+#include <memory>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <vector>

@@ -767,3 +769,69 @@ TEST_CASE("a write that throws leaves the same bytes in every kind of output")
    }
 }
 #endif
+
+#if !defined(JSON_NOEXCEPTION)
+namespace
+{
+
+// an adapter whose every write fails
+class failing_adapter : public nlohmann::detail::output_adapter_protocol<char>
+{
+  public:
+    [[noreturn]] void write_character(char /*c*/) override
+    {
+        throw std::runtime_error("write failed");
+    }
+
+    [[noreturn]] void write_characters(const char* /*s*/, std::size_t /*length*/) override
+    {
+        throw std::runtime_error("write failed");
+    }
+};
+
+} // namespace
+#endif
+
+TEST_CASE("output adapters")
+{
+    SECTION("writing a single character")
+    {
+        // the writers pass whole buffers on, but an adapter takes single
+        // characters as well
+        std::vector<char> as_vector;
+        nlohmann::detail::output_vector_adapter<char> vector_adapter(as_vector);
+        vector_adapter.write_character('a');
+        vector_adapter.write_character('b');
+        CHECK(as_vector == std::vector<char>({'a', 'b'}));
+
+        std::ostringstream as_stream;
+        nlohmann::detail::output_stream_adapter<char> stream_adapter(as_stream);
+        stream_adapter.write_character('c');
+        stream_adapter.write_character('d');
+        CHECK(as_stream.str() == "cd");
+
+        std::string as_string;
+        nlohmann::detail::output_string_adapter<char> string_adapter(as_string);
+        string_adapter.write_character('e');
+        string_adapter.write_character('f');
+        CHECK(as_string == "ef");
+    }
+
+#if !defined(JSON_NOEXCEPTION)
+    SECTION("a sink that is destroyed with characters left over")
+    {
+        // the destructor passes the pending characters on, as a write that
+        // threw leaves them there; the adapter failing then must not escape
+        {
+            nlohmann::detail::output_adapter_sink<char> sink(std::make_shared<failing_adapter>());
+            sink.write_character('x');
+        }
+
+        // while flush() reports the failure
+        nlohmann::detail::output_adapter_sink<char> sink(std::make_shared<failing_adapter>());
+        sink.write_character('x');
+        CHECK_THROWS_AS(sink.flush(), std::runtime_error&);
+        // (the character counts as written, so there is nothing left for the destructor)
+    }
+#endif
+}
@@ -2312,6 +2312,23 @@ TEST_CASE("BJData")
            CHECK_FALSE(json::sax_parse(v, &scp, json::input_format_t::bjdata));
        }

+        SECTION("every event of an ndarray of chars")
+        {
+            // the elements of an ndarray of 'C' are read one by one
+            std::vector<uint8_t> const v = {'[', '$', 'C', '#', '[', '$', 'U', '#', 'U', 2, 2, 2, 'a', 'b', 'c', 'd'};
+            // start_object, key, string, key, start_array, 2 numbers, end_array,
+            // key, start_array, 4 chars, end_array, end_object
+            constexpr int events = 16;
+            for (int allowed = 0; allowed < events; ++allowed)
+            {
+                CAPTURE(allowed)
+                SaxCountdown scp(allowed);
+                CHECK_FALSE(json::sax_parse(v, &scp, json::input_format_t::bjdata));
+            }
+            SaxCountdown scp(events);
+            CHECK(json::sax_parse(v, &scp, json::input_format_t::bjdata));
+        }
+
        SECTION("start_array() in ndarray _ArrayData_")
        {
            std::vector<uint8_t> const v = {'[', '$', 'U', '#', '[', 'i', 2, 'i', 3, ']', 6, 5, 4, 3, 2, 1};
@@ -3095,6 +3112,15 @@ TEST_CASE("BJData")
                json _;
                CHECK_THROWS_WITH(_ = json::from_bjdata(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing BJData char: byte after 'C' must be in range 0x00..0x7F; last byte: 0x82");
            }
+
+            SECTION("ndarray of chars cut off by the end of the input")
+            {
+                // 2x2 chars announced, three present
+                std::vector<uint8_t> const v = {'[', '$', 'C', '#', '[', '$', 'U', '#', 'U', 2, 2, 2, 'a', 'b', 'c'};
+                json _;
+                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(v), "[json.exception.parse_error.110] parse error at byte 16: syntax error while parsing BJData char: unexpected end of input", json::parse_error&);
+                CHECK(json::from_bjdata(v, true, false).is_discarded());
+            }
        }

        SECTION("byte")
@@ -329,6 +329,9 @@ TEST_CASE("BON8")
            check_bon8({false, nullptr, true}, {0x83, 0xF8, 0xFA, 0xF9});
            check_bon8({false, nullptr, true, 1.0}, {0x84, 0xF8, 0xFA, 0xF9, 0xFD});
            check_bon8({false, nullptr, true, 1.0, json::array(), 0.0}, {0x85, 0xF8, 0xFA, 0xF9, 0xFD, 0x80, 0xFC, 0xFE});
+            // an array that starts with a number: -1, 0, and 1 have bytes of their own
+            check_bon8({-1.0, 0.0, 1.0}, {0x83, 0xFB, 0xFC, 0xFD});
+            check_bon8({1.0, -1.0, -0.0}, {0x83, 0xFD, 0xFB, 0x8E, 0x80, 0x00, 0x00, 0x00});
            check_bon8({{{1}}}, {0x81, 0x81, 0x81, 0x91});
            check_bon8({{{"foo"}}}, {0x81, 0x81, 0x81, 'f', 'o', 'o', 0xFF});
            check_bon8({{{""}}}, {0x81, 0x81, 0x81, 0xFF});
@@ -23,7 +23,6 @@ using nlohmann::json;
 #include <cstdint>
 #include <fstream>
 #include <limits>
-#include <list>
 #include <sstream>
 #include <vector>
 #include "make_test_data_available.hpp"
@@ -82,8 +81,20 @@ class huge_string_t : public std::string
        return result;
    }

+    // returns a copy of @a s whose size() pretends to be @a n
+    static huge_string_t as_size(const std::string& s, const size_type n)
+    {
+        huge_string_t result(s);
+        result.fake_size = n;
+        return result;
+    }
+
    size_type size() const noexcept
    {
+        if (fake_size != 0)
+        {
+            return fake_size;
+        }
        if (pretend_huge)
        {
            // one byte more than the BSON length field can represent
@@ -94,6 +105,7 @@ class huge_string_t : public std::string

  private:
    bool pretend_huge = false;
+    size_type fake_size = 0;
 };

 using huge_string_json = nlohmann::json::with_string_t<huge_string_t>;
@@ -268,6 +280,17 @@ TEST_CASE("BSON")
            CHECK_THROWS_WITH_AS(huge_string_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_string_json::out_of_range&);
        }

+        SECTION("an array element that no longer fits the document")
+        {
+            // the string fits the length field, but not the document that
+            // holds it; nothing of it is written
+            const auto limit = static_cast<std::string::size_type>((std::numeric_limits<std::int32_t>::max)());
+            huge_string_json j;
+            j["a"] = huge_string_json::array({huge_string_t::as_size("value", limit - 8)});
+
+            CHECK_THROWS_AS(huge_string_json::to_bson(j), huge_string_json::out_of_range&);
+        }
+
        SECTION("document")
        {
            // an oversized string nested one level deep makes the
@@ -899,6 +922,38 @@ TEST_CASE("BSON")
            CHECK_THROWS_AS(_ = json::from_bson(input), json::parse_error&);
        }

+        SECTION("binary member with subtype 0x02 (old binary) with a truncated inner length")
+        {
+            // the inner length field is cut off by the end of the input
+            std::vector<std::uint8_t> const input =
+            {
+                0x0F, 0x00, 0x00, 0x00, // size (little endian)
+                0x05, 'a', 0x00, // entry: binary
+                0x08, 0x00, 0x00, 0x00, // size of binary (little endian)
+                0x02, // "old binary" subtype
+                0x01 // first byte of the inner length
+            };
+
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[json.exception.parse_error.110] parse error at byte 14: syntax error while parsing BSON number: unexpected end of input", json::parse_error&);
+            CHECK(json::from_bson(input, true, false).is_discarded());
+        }
+
+        SECTION("string member that is cut off by the end of the input")
+        {
+            std::vector<std::uint8_t> const input =
+            {
+                0x0F, 0x00, 0x00, 0x00, // size (little endian)
+                0x02, 'a', 0x00, // entry: string
+                0x0A, 0x00, 0x00, 0x00, // size of the string (little endian)
+                'b', 'c' // the string ends early
+            };
+
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[json.exception.parse_error.110] parse error at byte 14: syntax error while parsing BSON string: unexpected end of input", json::parse_error&);
+            CHECK(json::from_bson(input, true, false).is_discarded());
+        }
+
        SECTION("Some more complex document")
        {
            json const j =
@@ -1200,31 +1255,6 @@ TEST_CASE("BSON keys from contiguous and stream input")
            from_stream = e.what();
        }
        CHECK(from_vector == from_stream);
-
-        // error_handler_t::strict checks the array element names in place on
-        // contiguous input and byte by byte otherwise; the names are
-        // well-formed, so both give the same value or error as above
-        std::string strict_from_vector;
-        std::string strict_from_list;
-        try
-        {
-            strict_from_vector = json::from_bson(input, true, true, json::error_handler_t::strict).dump();
-        }
-        catch (const json::parse_error& e)
-        {
-            strict_from_vector = e.what();
-        }
-        try
-        {
-            const std::list<std::uint8_t> list(input.begin(), input.end());
-            strict_from_list = json::from_bson(list.begin(), list.end(), true, true, json::error_handler_t::strict).dump();
-        }
-        catch (const json::parse_error& e)
-        {
-            strict_from_list = e.what();
-        }
-        CHECK(strict_from_vector == from_vector);
-        CHECK(strict_from_list == from_vector);
    }
 }

@@ -1253,18 +1283,6 @@ TEST_CASE("BSON array element names")

    std::istringstream stream(std::string(reinterpret_cast<const char*>(bson.data()), bson.size()));
    CHECK(json::from_bson(stream) == expected);
-
-    // input that is not contiguous reads the names byte by byte and must reject
-    // the same name
-    const std::list<std::uint8_t> list(bson.begin(), bson.end());
-    CHECK_THROWS_WITH_AS(_ = json::from_bson(list.begin(), list.end(), true, true, json::error_handler_t::strict), "[json.exception.parse_error.113] parse error at byte 14: syntax error while parsing BSON key: invalid string: ill-formed UTF-8 byte", json::parse_error&);
-
-    // without exceptions, the rejected name ends the parse
-    CHECK(json::from_bson(bson, true, false, json::error_handler_t::strict).is_discarded());
-
-    // well-formed names pass the check without being stored
-    const json valid = {{"a", {true, false, {{"k", json::array({1, 2})}}}}};
-    CHECK(json::from_bson(json::to_bson(valid), true, true, json::error_handler_t::strict) == valid);
 }
 #endif

@@ -2174,6 +2192,25 @@ value = depth % 2 == 0 ? json{{"a", std::move(value)}, {"b", {1, "x"}}} :
        CHECK(output.empty());
    }

+#if !defined(JSON_NOEXCEPTION)
+    SECTION("U+0000 in a long key is found at any position")
+    {
+        // the key is searched eight characters at a time
+        for (const std::string& key :
+                {
+                    std::string("abc\0defghijkl", 12), std::string("abcdefgh\0ijkl", 13), std::string("abcdefghijklmnop\0", 17), std::string("\0abcdefghijkl", 13),
+                    std::string("abcdefghijklmno\0", 16)
+                })
+        {
+            CAPTURE(key)
+            const json value = json::object({{key, 1}});
+            std::vector<std::uint8_t> output;
+            CHECK_THROWS_AS(json::to_bson(value, output), json::out_of_range&);
+            CHECK(output.empty());
+        }
+    }
+#endif
+
    SECTION("a binary subtype that doesn't fit a byte is rejected before anything is written (#5675)")
    {
        // the offending value is nested, so this also covers that the check
@@ -1809,6 +1809,30 @@ TEST_CASE("CBOR")
            CHECK(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01}), true, false).is_discarded());
        }

+        SECTION("tag in front of a key that is cut off by the end of the input")
+        {
+            // 0xD8: the tag number is in the next byte, which is missing
+            const std::vector<std::uint8_t> input = {0xA1, 0xD8};
+            json _;
+            for (const auto handler :
+                    {
+                        json::cbor_tag_handler_t::ignore, json::cbor_tag_handler_t::store
+                    })
+            {
+                CHECK_THROWS_WITH_AS(_ = json::from_cbor(input, true, true, handler), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing CBOR number: unexpected end of input", json::parse_error&);
+                CHECK(json::from_cbor(input, true, false, handler).is_discarded());
+            }
+        }
+
+        SECTION("chunk of an indefinite-length string that is cut off by the end of the input")
+        {
+            // the second byte announces a chunk of three bytes, but two follow
+            const std::vector<std::uint8_t> input = {0x7F, 0x63, 'a', 'b'};
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
+            CHECK(json::from_cbor(input, true, false).is_discarded());
+        }
+
        SECTION("tag in front of a key")
        {
            const auto ignore = json::cbor_tag_handler_t::ignore;
@@ -2092,6 +2092,12 @@ TEST_CASE("UTF-8 validators accept the same sequences")
        }
    };

+    // an ASCII byte is a sequence of its own
+    for (unsigned lead = 0; lead < 0x80; ++lead)
+    {
+        CHECK(nlohmann::detail::utf8_shape(static_cast<std::uint8_t>(lead)).length == 1);
+    }
+
    for (unsigned lead = 0x80; lead <= 0xFF; ++lead)
    {
        const auto shape = nlohmann::detail::utf8_shape(static_cast<std::uint8_t>(lead));
@@ -2157,3 +2163,72 @@ TEST_CASE("UTF-8 validators accept the same sequences")
        }
    }
 }
+
+TEST_CASE("float_bigint")
+{
+    // the big integer of the exact comparison of a float token with the
+    // midpoint between two floats (digit_comparison())
+    using nlohmann::detail::float_bigint;
+
+    SECTION("zero")
+    {
+        // shifting zero keeps it zero, whatever the distance
+        float_bigint zero(0);
+        zero.shift_left(0);
+        zero.shift_left(5);
+        zero.shift_left(64);
+        CHECK(zero.compare(float_bigint(0)) == 0);
+        CHECK(zero.compare(float_bigint(1)) == -1);
+        CHECK(float_bigint(1).compare(zero) == 1);
+    }
+
+    SECTION("compare numbers of different lengths")
+    {
+        // the number with more 32-bit limbs is the greater one
+        const float_bigint small(0xFFFFFFFFu);
+        const float_bigint large(std::uint64_t{1} << 32u);
+        CHECK(small.compare(large) == -1);
+        CHECK(large.compare(small) == 1);
+        CHECK(large.compare(large) == 0);
+
+        // a shift can add a limb
+        float_bigint shifted(1);
+        shifted.shift_left(32);
+        CHECK(shifted.compare(large) == 0);
+        shifted.shift_left(1);
+        CHECK(shifted.compare(large) == 1);
+        CHECK(large.compare(shifted) == -1);
+    }
+
+    SECTION("compare numbers of the same length")
+    {
+        CHECK(float_bigint(2).compare(float_bigint(3)) == -1);
+        CHECK(float_bigint(3).compare(float_bigint(2)) == 1);
+        CHECK(float_bigint(3).compare(float_bigint(3)) == 0);
+        CHECK(float_bigint((std::uint64_t{3} << 32u) | 1u).compare(float_bigint((std::uint64_t{3} << 32u) | 2u)) == -1);
+    }
+}
+
+TEST_CASE("serialization of short strings")
+{
+    // the serializer takes strings of up to 32 characters that need no
+    // escaping by a table lookup of its own where the scan is not vectorized
+    // (this file is built that way, too, with JSON_NO_SIMD)
+    for (const std::string& s :
+            {
+                std::string(), std::string("a"), std::string("hello"), std::string("0123456789abcdef"), std::string("0123456789abcdef0123456789abcdef"),
+                std::string("0123456789abcdef0123456789abcdef0")
+            })
+    {
+        CAPTURE(s)
+        const json j = s;
+        CHECK(j.dump() == "\"" + s + "\"");
+        CHECK(j.dump(-1, ' ', true) == "\"" + s + "\"");
+        CHECK(json({{s, s}}).dump() == "{\"" + s + "\":\"" + s + "\"}");
+    }
+
+    // a character that needs an escape
+    CHECK(json("a\"b").dump() == "\"a\\\"b\"");
+    CHECK(json("caf\xC3\xA9").dump() == "\"caf\xC3\xA9\"");
+    CHECK(json("caf\xC3\xA9").dump(-1, ' ', true) == "\"caf\\u00e9\"");
+}
@@ -210,3 +210,23 @@ TEST_CASE("regression test #5476 - array type without reserve()")
        CHECK(json::from_cbor(truncated, true, false).is_discarded());
    }
 }
+
+TEST_CASE("array type with std::deque nested beyond the recursion limit")
+{
+    // the binary writers finish a value nested deeper than
+    // recursion_depth_limit() with an explicit stack of frames; with the
+    // iterators of std::deque, these frames are copied and moved through
+    // their own special members
+    deque_json j = 1;
+    for (int i = 0; i < 200; ++i)
+    {
+        deque_json outer = deque_json::array();
+        outer.push_back(std::move(j));
+        j = std::move(outer);
+    }
+
+    // 200 arrays of one element each (0x81) around the integer 1
+    std::vector<std::uint8_t> expected(200, 0x81);
+    expected.push_back(0x01);
+    CHECK(deque_json::to_cbor(j) == expected);
+}
@@ -7,7 +7,6 @@
 // SPDX-License-Identifier: MIT

 #include <algorithm>
-#include <memory>
 #include <set>
 #include <sstream>
 #include <string>
@@ -496,92 +495,3 @@ TEST_CASE("Regression test for issue #5674 - copy construction must not require
        CHECK(*c == 1);
    }
 }
-
-// counts the constructions and destructions of the base class (#5995)
-struct counting_base
-{
-    static std::size_t constructions;
-    static std::size_t destructions;
-
-    counting_base() noexcept
-    {
-        ++constructions;
-    }
-    counting_base(const counting_base& /*unused*/) noexcept
-    {
-        ++constructions;
-    }
-    counting_base(counting_base&& /*unused*/) noexcept
-    {
-        ++constructions;
-    }
-    counting_base& operator=(const counting_base& /*unused*/) noexcept = default;
-    counting_base& operator=(counting_base&& /*unused*/) noexcept = default;
-    ~counting_base()
-    {
-        ++destructions;
-    }
-
-    static void reset() noexcept
-    {
-        constructions = 0;
-        destructions = 0;
-    }
-};
-
-std::size_t counting_base::constructions = 0;
-std::size_t counting_base::destructions = 0;
-
-using json_with_counting_base = nlohmann::json::with_base_class_t<counting_base>;
-
-TEST_CASE("destroying a value does not construct the custom base class")
-{
-    // regression test for #5995: destroying an array or object used a
-    // default-constructed basic_json as a stand-in, which constructed a base
-    // class that belonged to no value (and could allocate in the noexcept
-    // destructor); now every destroyed value destroys exactly its own base
-    // object, and none is constructed
-    const auto check_destroy = [](std::unique_ptr<json_with_counting_base> j, std::size_t values)
-    {
-        counting_base::reset();
-        j = nullptr;
-        CHECK(counting_base::constructions == 0);
-        CHECK(counting_base::destructions == values);
-    };
-
-    SECTION("scalar")
-    {
-        check_destroy(std::unique_ptr<json_with_counting_base>(new json_with_counting_base(42)), 1);
-    }
-
-    SECTION("array and object")
-    {
-        check_destroy(std::unique_ptr<json_with_counting_base>(new json_with_counting_base(json_with_counting_base::parse(R"({"a":[1,2,3],"b":{"c":true}})"))), 7);
-        check_destroy(std::unique_ptr<json_with_counting_base>(new json_with_counting_base(json_with_counting_base::array())), 1);
-    }
-
-    SECTION("nested deeper than the recursion depth limit")
-    {
-        // alternating arrays and objects, so both kinds of container are
-        // walked by destroy_walk()
-        constexpr std::size_t depth = 1000;
-        std::unique_ptr<json_with_counting_base> j(new json_with_counting_base(json_with_counting_base::array({1, 2})));
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            json_with_counting_base outer = (i % 2 == 0) ? json_with_counting_base::object() : json_with_counting_base::array();
-            if (outer.is_object())
-            {
-                outer["x"] = std::move(*j);
-                outer["y"] = nullptr;
-            }
-            else
-            {
-                outer.push_back(std::move(*j));
-                outer.push_back(true);
-            }
-            *j = std::move(outer);
-        }
-        // the innermost array with its two elements, and two values per level
-        check_destroy(std::move(j), 3 + (2 * depth));
-    }
-}
@@ -49,3 +49,24 @@ TEST_CASE("custom object key types: MessagePack (json_full)")
 {
    custom_key_test::test_msgpack<json_full>();
 }
+
+TEST_CASE("custom object key types: patch (json_full)")
+{
+    // the members of a patch are found by lookup, as their keys are not std::string
+    const json_full j = json_full::parse(R"({"a":1,"b":[1,2],"c":{"d":2}})");
+    const json_full patch = json_full::parse(R"([
+        {"op": "add", "path": "/e", "value": 5},
+        {"op": "remove", "path": "/a"},
+        {"op": "replace", "path": "/c/d", "value": 3},
+        {"op": "test", "path": "/c/d", "value": 3},
+        {"op": "move", "from": "/e", "path": "/f"},
+        {"op": "copy", "from": "/f", "path": "/g"},
+        {"op": "add", "path": "/b/-", "value": 7}
+    ])");
+
+    CHECK(j.patch(patch).dump() == R"({"b":[1,2,7],"c":{"d":3},"f":5,"g":5})");
+
+    // a patch with a missing member is rejected
+    CHECK_THROWS_AS(j.patch(json_full::parse(R"([{"op": "add", "path": "/e"}])")), json_full::parse_error&);
+    CHECK_THROWS_AS(j.patch(json_full::parse(R"([{"op": "test", "path": "/a", "value": 2}])")), json_full::other_error&);
+}
@@ -337,6 +337,52 @@ TEST_CASE("custom number types: integers beyond 64 bits")
        CHECK(wide_json::to_bson(fit_members) == nlohmann::json::to_bson(fit_members64));
    }

+    SECTION("MessagePack integers of every width")
+    {
+        // an integer of a number type wider than 64 bits is written with the
+        // smallest MessagePack integer that holds it, as for 64-bit types
+        const wide_json widths = wide_json::array(
+        {
+            make_int(-33), make_int(-100), make_int(-128), make_int(-129), make_int(-32768), make_int(-32769), make_int(-2147483648LL), make_int(-2147483649LL),
+            make_int(128), make_int(255), make_int(256), make_int(300), make_int(65535), make_int(65536), make_int(70000), make_int(4294967295LL), make_int(4294967296LL),
+            make_uint(128), make_uint(255), make_uint(256), make_uint(300), make_uint(65535), make_uint(65536), make_uint(70000), make_uint(4294967295ULL), make_uint(4294967296ULL)
+        });
+        const nlohmann::json widths64 = nlohmann::json::array(
+        {
+            -33, -100, -128, -129, -32768, -32769, -2147483648LL, -2147483649LL,
+            128, 255, 256, 300, 65535, 65536, 70000, 4294967295LL, 4294967296LL,
+            128u, 255u, 256u, 300u, 65535u, 65536u, 70000u, 4294967295ULL, 4294967296ULL
+        });
+        CHECK(wide_json::to_msgpack(widths) == nlohmann::json::to_msgpack(widths64));
+
+        // as single values, too
+        CHECK(wide_json::to_msgpack(make_int(-100)) == std::vector<std::uint8_t>({0xD0, 0x9C}));
+        CHECK(wide_json::to_msgpack(make_int(300)) == std::vector<std::uint8_t>({0xCD, 0x01, 0x2C}));
+        CHECK(wide_json::to_msgpack(make_int(70000)) == std::vector<std::uint8_t>({0xCE, 0x00, 0x01, 0x11, 0x70}));
+        CHECK(wide_json::to_msgpack(make_uint(300)) == std::vector<std::uint8_t>({0xCD, 0x01, 0x2C}));
+        CHECK(wide_json::to_msgpack(make_uint(70000)) == std::vector<std::uint8_t>({0xCE, 0x00, 0x01, 0x11, 0x70}));
+    }
+
+    SECTION("dump")
+    {
+        // beyond 64 bits, the digits are counted before they are written
+        CHECK(make_int(0).dump() == "0");
+        CHECK(make_int(two_64).dump() == "18446744073709551616");
+        CHECK(make_int(-two_64).dump() == "-18446744073709551616");
+        CHECK(make_int(two_100).dump() == "1267650600228229401496703205376");
+        CHECK(make_int(-two_100).dump() == "-1267650600228229401496703205376");
+        // powers of ten, where the count of digits ends on a single digit or two
+        const int128 ten_20 = static_cast<int128>(100000000000ULL) * static_cast<int128>(1000000000ULL);
+        CHECK(make_int(ten_20).dump() == "100000000000000000000");
+        CHECK(make_int(-ten_20).dump() == "-100000000000000000000");
+        CHECK(make_int(ten_20 * 10).dump() == "1000000000000000000000");
+        CHECK(make_int(ten_20 * 100).dump() == "10000000000000000000000");
+        CHECK(make_int(ten_20 * 1000).dump() == "100000000000000000000000");
+        CHECK(make_uint(static_cast<uint128>(ten_20) * 10u).dump() == "1000000000000000000000");
+        CHECK(make_uint((std::numeric_limits<uint128>::max)()).dump() == "340282366920938463463374607431768211455");
+        CHECK(make_int((std::numeric_limits<int128>::min)()).dump() == "-170141183460469231731687303715884105728");
+    }
+
    SECTION("BJData ND-array")
    {
        // an ND-array element beyond 64 bits does not fit any dtype, so the
@@ -417,3 +463,23 @@ TEST_CASE("custom number types")
    }

 }
+
+TEST_CASE("custom number types: 32-bit integers in the binary formats")
+{
+    // integers narrower than 64 bits are widened (a signed one with its sign)
+    // before the CBOR, MessagePack, and UBJSON writers pick their encoding
+    using json32 = nlohmann::json::with_integers_t<std::int32_t, std::uint32_t>;
+    json32 values = json32::array();
+    values.push_back(std::uint32_t{0});
+    values.push_back(std::uint32_t{200});
+    values.push_back(std::uint32_t{4294967295u});
+    values.push_back(std::int32_t{-1});
+    values.push_back(std::int32_t{-2147483647 - 1});
+    REQUIRE(values[2].is_number_unsigned());
+    REQUIRE(values[4].is_number_integer());
+
+    const nlohmann::json values64 = {0u, 200u, 4294967295u, -1, -2147483648LL};
+    CHECK(json32::to_cbor(values) == nlohmann::json::to_cbor(values64));
+    CHECK(json32::to_msgpack(values) == nlohmann::json::to_msgpack(values64));
+    CHECK(json32::to_ubjson(values) == nlohmann::json::to_ubjson(values64));
+}
@@ -11,8 +11,13 @@
 #include <nlohmann/json.hpp>

 #include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
+#include <vector>

 #include "custom_object_key_type.hpp"

@@ -125,3 +130,161 @@ TEST_CASE("MessagePack supports custom object key types nested deeper than the r
    CHECK(encoded == nlohmann::json::to_msgpack(expected));
    CHECK(nlohmann::json::from_msgpack(encoded) == expected);
 }
+
+namespace
+{
+// A key type that cannot be constructed from a std::string, so that a value
+// with such keys cannot be converted from a nlohmann::json by the range
+// constructor of its object type: the serializer converts the object instead.
+class strict_key
+{
+  public:
+    strict_key(const char* value)
+        : m_value(value)
+    {}
+
+    strict_key(const std::string& /*value*/) = delete;
+
+#if JSON_DIAGNOSTICS
+    // Required by JSON_DIAGNOSTICS, which reads object keys through data()
+    // when building the path of an exception.
+    const char* data() const noexcept
+    {
+        return m_value.data();
+    }
+#endif
+
+    friend bool operator<(const strict_key& lhs, const strict_key& rhs)
+    {
+        return lhs.m_value < rhs.m_value;
+    }
+
+  private:
+    std::string m_value{};
+};
+
+strict_key make_strict_key(const std::string& key)
+{
+    return strict_key(key.c_str());
+}
+
+template<class Key, class Value, class Compare, class Allocator>
+class strict_object
+    : public std::map <
+      strict_key,
+      Value,
+      std::less<strict_key>, // NOLINT(modernize-use-transparent-functors)
+      typename std::allocator_traits<Allocator>::template rebind_alloc <
+          std::pair<const strict_key, Value >>>
+{
+  public:
+    strict_object() = default;
+};
+
+template<typename T, typename = void>
+struct strict_serializer : nlohmann::adl_serializer<T> {};
+
+using strict_json = nlohmann::basic_json < strict_object, std::vector, std::string, bool, std::int64_t,
+      std::uint64_t, double, std::allocator, strict_serializer, std::vector<std::uint8_t >>;
+
+// the members of an object are converted one by one, their keys by make_strict_key()
+template<>
+struct strict_serializer<nlohmann::json::object_t, void>
+{
+    static void to_json(strict_json& j, const nlohmann::json::object_t& object)
+    {
+        strict_json::object_t converted;
+        for (const auto& member : object)
+        {
+            converted.emplace(make_strict_key(member.first), strict_json(member.second));
+        }
+        j = strict_json(std::move(converted));
+    }
+};
+} // namespace
+
+TEST_CASE("converting a value with keys that cannot be made from a std::string nested deeper than the recursion depth limit")
+{
+    static_assert(!std::is_constructible<strict_key, const std::string&>::value, "the keys cannot be made from a std::string");
+
+    // below detail::recursion_depth_limit(), objects and arrays are converted
+    // by the serializers instead of the range constructors
+    const std::size_t depth = nlohmann::detail::recursion_depth_limit() + 10;
+
+    nlohmann::json value = 1;
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        if (i % 2 == 0)
+        {
+            value = nlohmann::json::object({{"a", std::move(value)}, {"b", true}});
+        }
+        else
+        {
+            value = nlohmann::json::array({std::move(value), "sibling"});
+        }
+    }
+
+    const strict_json converted = value;
+
+    // at() needs to make a std::string of a key for its error message
+    const auto member = [](const strict_json & object, const char* name) -> const strict_json &
+    {
+        const auto it = object.find(strict_key(name));
+        REQUIRE(it != object.end());
+        return *it;
+    };
+
+    // walk down the nesting levels without recursion
+    const strict_json* current = &converted;
+    for (std::size_t i = depth; i > 0; --i)
+    {
+        if (i % 2 == 1)
+        {
+            REQUIRE(current->is_object());
+            CHECK(current->size() == 2);
+            CHECK(member(*current, "b").get<bool>());
+            current = &member(*current, "a");
+        }
+        else
+        {
+            REQUIRE(current->is_array());
+            CHECK(current->size() == 2);
+            CHECK(current->at(1).get<std::string>() == "sibling");
+            current = &current->at(0);
+        }
+    }
+    CHECK(current->get<int>() == 1);
+}
+
+namespace
+{
+// shorter keys come first
+struct shortlex_less
+{
+    bool operator()(const std::string& lhs, const std::string& rhs) const
+    {
+        return lhs.size() != rhs.size() ? lhs.size() < rhs.size() : lhs < rhs;
+    }
+};
+
+template<class Key, class Value, class Compare, class Allocator>
+using shortlex_map = std::map<Key, Value, shortlex_less, Allocator>;
+
+using shortlex_json = nlohmann::json::with_object_t<shortlex_map>;
+} // namespace
+
+TEST_CASE("unflatten with an object type that does not sort the keys alphabetically")
+{
+    // the keys of /a come before and after one of /b: unlike in an object
+    // sorted alphabetically, the values below a prefix are not found one
+    // after the other, so the value of /a must be looked up again
+    shortlex_json flat = shortlex_json::object();
+    flat["/a/p"] = 1;
+    flat["/b/qq"] = 2;
+    flat["/a/pqr"] = 3;
+    REQUIRE(flat.begin().key() == "/a/p");
+    REQUIRE((++flat.begin()).key() == "/b/qq");
+
+    CHECK(flat.unflatten().dump() == R"({"a":{"p":1,"pqr":3},"b":{"qq":2}})");
+    CHECK(flat.unflatten().flatten() == flat);
+}
@@ -1195,6 +1195,28 @@ TEST_CASE("deserialization")
 #endif
 }

+#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
+TEST_CASE("deserialization from a pointer and a length (deprecated)")
+{
+    // the unit test build disables -Wdeprecated-declarations (see
+    // cmake/clang_flags.cmake)
+    const std::string text = R"({"foo": [1, 2, 3]})";
+    const std::string invalid = R"({"foo": )";
+
+    SECTION("parse")
+    {
+        const json j = json::parse({text.data(), text.size()});
+        CHECK(j == json({{"foo", {1, 2, 3}}}));
+    }
+
+    SECTION("accept")
+    {
+        CHECK(json::accept({text.data(), text.size()}));
+        CHECK_FALSE(json::accept({invalid.data(), invalid.size()}));
+    }
+}
+#endif
+
 // select the types to test - char8_t is only available since C++20 if and only
 // if __cpp_char8_t is defined.
 #define TYPE_LIST(...) __VA_ARGS__
@@ -868,3 +868,23 @@ TEST_CASE("Parent pointers stay consistent for object types not known to keep th
    obj["1"].push_back(42);
    CHECK_THROWS_WITH_AS(obj["1"].at(5), "[json.exception.out_of_range.401] (/1) array index 5 is out of range", relocating_json::out_of_range&);
 }
+
+TEST_CASE("patch_inplace() with a patch that is stored inside the patched value")
+{
+    // the patch is modified-while-iterated if it is not copied first: it is a
+    // descendant of the value it is applied to, which only the parent pointers
+    // (JSON_DIAGNOSTICS) reveal
+    json j =
+    {
+        {"patch", {{{"op", "add"}, {"path", "/x"}, {"value", 1}}, {{"op", "remove"}, {"path", "/patch/0"}}}},
+        {"y", 2}
+    };
+
+    j.patch_inplace(j["patch"]);
+
+    CHECK(j.size() == 3);
+    CHECK(j["x"] == 1);
+    CHECK(j["y"] == 2);
+    CHECK(j["patch"].size() == 1);
+    CHECK(j["patch"][0]["op"] == "remove");
+}
@@ -18,6 +18,8 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

+#include <iterator>
+
 #if JSON_HAS_RANGES
    #include <algorithm>
    #include <ranges>
@@ -665,6 +667,23 @@ TEST_CASE("iterators 2")
        }
    }

+    SECTION("reverse iterators of a const value")
+    {
+        const json j_array = {1, 2, 3};
+        const json j_object = {{"one", 1}, {"two", 2}};
+
+        // rbegin() and rend() of a const value are crbegin() and crend()
+        CHECK(j_array.rbegin() == j_array.crbegin());
+        CHECK(j_array.rend() == j_array.crend());
+        CHECK(*j_array.rbegin() == 3);
+        CHECK(std::distance(j_array.rbegin(), j_array.rend()) == 3);
+
+        CHECK(j_object.rbegin() == j_object.crbegin());
+        CHECK(j_object.rend() == j_object.crend());
+        CHECK(j_object.rbegin().key() == "two");
+        CHECK(std::distance(j_object.rbegin(), j_object.rend()) == 2);
+    }
+
    SECTION("reverse iterator arithmetic")
    {
        json j_object = {{"one", 1}, {"two", 2}, {"three", 3}};
@@ -14,9 +14,11 @@ using nlohmann::json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif

+#include <cstddef>
 #include <fstream>
 #include <limits>
 #include <string>
+#include <utility>
 #include <vector>
 #include "make_test_data_available.hpp"

@@ -2453,3 +2455,99 @@ TEST_CASE("JSON patch - diff behavior documented in the API reference")
        CHECK(json::diff(json(nullptr), json::array()) == R"([{"op": "replace", "path": "", "value": []}])"_json);
    }
 }
+
+TEST_CASE("JSON patch - operations that are left to json_pointer")
+{
+    // the usual operations on a plain pointer are applied without building a
+    // json_pointer; the following are not plain, and some are errors
+    SECTION("a path without a slash")
+    {
+        const json j = {{"a", 1}};
+
+        CHECK_THROWS_AS(j.patch(R"([{"op": "add", "path": "abc", "value": 1}])"_json), json::parse_error&);
+        CHECK_THROWS_AS(j.patch(R"([{"op": "remove", "path": "abc"}])"_json), json::parse_error&);
+    }
+
+    SECTION("remove with an escaped reference token")
+    {
+        const json j = {{"a/b", 1}, {"c~d", 2}, {"e", 3}};
+
+        CHECK(j.patch(R"([{"op": "remove", "path": "/a~1b"}])"_json) == json({{"c~d", 2}, {"e", 3}}));
+        CHECK(j.patch(R"([{"op": "remove", "path": "/c~0d"}])"_json) == json({{"a/b", 1}, {"e", 3}}));
+        CHECK_THROWS_AS(j.patch(R"([{"op": "remove", "path": "/missing~1key"}])"_json), json::out_of_range&);
+    }
+
+    SECTION("a path through a primitive value")
+    {
+        const json j = {{"a", 1}};
+
+        CHECK_THROWS_AS(j.patch(R"([{"op": "test", "path": "/a/b", "value": 1}])"_json), json::other_error&);
+        CHECK_THROWS_AS(j.patch(R"([{"op": "replace", "path": "/a/b", "value": 1}])"_json), json::out_of_range&);
+    }
+}
+
+TEST_CASE("JSON patch - diff of objects with many members")
+{
+    // more members than diff() keeps without allocating
+    for (const std::size_t members :
+            {
+                16u, 17u, 40u
+            })
+    {
+        CAPTURE(members)
+
+        json source = json::object();
+        json target = json::object();
+        for (std::size_t i = 0; i < members; ++i)
+        {
+            const std::string key = "key" + std::to_string(i);
+            source[key] = i;
+            // every third member differs
+            target[key] = (i % 3 == 0) ? i + 1 : i;
+        }
+        // the same keys, a removed and an added one
+        source["removed"] = true;
+        target["added"] = false;
+
+        const json patch = json::diff(source, target);
+        CHECK(source.patch(patch) == target);
+        CHECK(patch.size() == ((members + 2) / 3) + 2);
+
+        const nlohmann::ordered_json ordered_source = source;
+        const nlohmann::ordered_json ordered_target = target;
+        CHECK(ordered_source.patch(nlohmann::ordered_json::diff(ordered_source, ordered_target)) == ordered_target);
+    }
+}
+
+TEST_CASE("JSON patch - diff of leaf values below the bound of the recursive descent")
+{
+    // the values at the innermost level are diffed without recursion: equal
+    // leaves yield nothing, leaves of different types and different leaves
+    // are replaced
+    const std::size_t depth = 200;
+
+    json source = {1, "text", 3, {{"x", 1}, {"y", 2}}, true, nullptr};
+    json target = {1, 2, 4, {{"x", 1}, {"y", 3}}, true, nullptr};
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        source = json::array({std::move(source)});
+        target = json::array({std::move(target)});
+    }
+
+    const json patch = json::diff(source, target);
+    CHECK(patch.size() == 3);
+    CHECK(source.patch(patch) == target);
+
+    // the same with objects as the outer levels
+    json object_source = {{"equal", 1}, {"type", "text"}, {"value", 3}};
+    json object_target = {{"equal", 1}, {"type", 2}, {"value", 4}};
+    for (std::size_t i = 0; i < depth; ++i)
+    {
+        object_source = json::object({{"a", std::move(object_source)}});
+        object_target = json::object({{"a", std::move(object_target)}});
+    }
+
+    const json object_patch = json::diff(object_source, object_target);
+    CHECK(object_patch.size() == 2);
+    CHECK(object_source.patch(object_patch) == object_target);
+}
@@ -106,6 +106,12 @@ TEST_CASE("JSON pointers")
        CHECK_THROWS_WITH_AS(p.pop_back(),
                             "[json.exception.out_of_range.405] JSON pointer has no parent", json::out_of_range&);

+        // the top of a pointer is its first reference token
+        const json::json_pointer nonempty("/foo/bar/0");
+        CHECK(nonempty.top() == json::json_pointer("/foo"));
+        CHECK(nonempty.top().to_string() == "/foo");
+        CHECK(json::json_pointer("/a~1b").top() == json::json_pointer("/a~1b"));
+
        SECTION("array index error")
        {
            json v = {1, 2, 3, 4};
@@ -697,6 +703,16 @@ TEST_CASE("JSON pointers")
        CHECK_THROWS_WITH_AS(j_error.unflatten(),
                             "[json.exception.type_error.313] invalid value to unflatten", json::type_error&);

+        // error for an invalid escape sequence in a key
+        CHECK_THROWS_WITH_AS(json({{"/a~2", 1}}).unflatten(),
+        "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
+        CHECK_THROWS_WITH_AS(json({{"/a/b", 1}, {"/c~", 1}}).unflatten(),
+        "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
+
+        // error for an element of an array that is also a container
+        CHECK_THROWS_WITH_AS(json({{"/a/0", 1}, {"/a/0/x", 2}}).unflatten(),
+        "[json.exception.type_error.313] invalid value to unflatten", json::type_error&);
+
        // explicit roundtrip check
        CHECK(j.flatten().unflatten() == j);

@@ -31,9 +31,11 @@ using json_view_test::has_duplicate_keys;
 #include <ios>
 #include <istream>
 #include <iterator>
+#include <functional>
 #include <limits>
 #include <list>
 #include <map>
+#include <new>
 #include <random>
 #include <sstream>
 #include <string>
@@ -98,6 +100,37 @@ template<typename View>
 using bool_conversion_t = decltype(static_cast<bool>(std::declval<View>()));

 #if !defined(JSON_NOEXCEPTION)
+// an allocator that never has room
+template<typename T>
+struct failing_allocator
+{
+    using value_type = T;
+
+    failing_allocator() = default;
+
+    template<typename U>
+    explicit failing_allocator(const failing_allocator<U>& /*other*/) noexcept {}
+
+    T* allocate(std::size_t /*n*/) // NOLINT(readability-convert-member-functions-to-static)
+    {
+        throw std::bad_alloc();
+    }
+
+    void deallocate(T* /*p*/, std::size_t /*n*/) noexcept {} // NOLINT(readability-convert-member-functions-to-static)
+
+    template<typename U>
+    bool operator==(const failing_allocator<U>& /*other*/) const noexcept
+    {
+        return true;
+    }
+
+    template<typename U>
+    bool operator!=(const failing_allocator<U>& /*other*/) const noexcept
+    {
+        return false;
+    }
+};
+
 // the exception parse() throws for a text, or "" if it accepts it
 std::string parse_exception(const std::string& text, bool comments = false, bool trailing_commas = false)
 {
@@ -235,7 +268,9 @@ TEST_CASE("json_view")
                {
                    "", " ", "[", "]", "{", "[1,]", "{\"a\":1,}", "[1 2]", "{\"a\" 1}", "{1:2}", "tru", "nul", "fals", "truex", "-", "01", "1.", ".5", "1e",
                    "\"", "\"abc", "\"\\x\"", "\"\\u12\"", "\"\\ud800\"", "\"\\udc00\"", "\"\x01\"", "\"\xff\"", "\"\xc3\"", "[1]x", "/", "/*", "[\n  1,\n  x\n]", // NOLINT(modernize-raw-string-literal)
-                    "1e400", "-1e400", "[1.7976931348623159e308]", "{\"a\":\n{\"b\": [1, 2,\n 3 x]}}"
+                    "1e400", "-1e400", "[1.7976931348623159e308]", "{\"a\":\n{\"b\": [1, 2,\n 3 x]}}",
+                    // (an error after every kind of value: the error is found by replaying the parser)
+                    "[null, true, -1, 1, 1.5, \"s\", {\"a\": 1} 2]", "{\"a\": null, \"b\": -1, \"c\": 1.5, \"d\": \"s\", \"e\": {}, 1}"
                })
        {
            CAPTURE(text)
@@ -368,6 +403,10 @@ TEST_CASE("json_view")
        CHECK(from_stream.root().materialize() == expected);
        const std::list<char> list(text.begin(), text.end());
        CHECK(json_document::parse(list.begin(), list.end()).owns_source());
+        // (an input that is not valid)
+        const std::list<char> bad_list{'[', '1', ','};
+        json_document from_bad_list;
+        CHECK_THROWS_AS(from_bad_list = json_document::parse(bad_list.begin(), bad_list.end()), json::parse_error&);
        CHECK(materialized<json_document>(list.begin(), list.end()) == expected);

        // iterator pairs: pointers are borrowed, and so are contiguous library
@@ -1511,6 +1550,17 @@ TEST_CASE("json_view values")
        const json_document dup = json_document::parse(R"({"a":1,"a":2})");
        CHECK((dup.root().get<std::map<std::string, int>>() == std::map<std::string, int> {{"a", 2}}));

+        // a map of views from something that is not an object
+        using view_map = std::map<std::string, json_view>;
+        const json_document not_an_object = json_document::parse("[1,2]");
+        CHECK_THROWS_WITH_AS(not_an_object.root().get<view_map>(), json_view_test::message("type_error.302", "", 0, 5, "type must be object, but is array").c_str(), json::type_error&);
+#if !defined(JSON_NOEXCEPTION)
+        // (and one that cannot allocate its nodes)
+        using failing_map = std::map<std::string, json_view, std::less<std::string>, failing_allocator<std::pair<const std::string, json_view>>>;
+        const json_document one_member = json_document::parse(R"({"a":1})");
+        CHECK_THROWS_AS(one_member.root().get<failing_map>(), std::bad_alloc&);
+#endif
+
        const json_view invalid{};
        CHECK_THROWS_WITH_AS(invalid.get<int>(), "[json.exception.type_error.302] type must be number, but is discarded", json::type_error&);
        CHECK(invalid.get<json>().is_discarded());
@@ -692,7 +692,7 @@ TEST_CASE("json_view builder: fraction digits")
            check_same(number);
            check_same("[" + number + "]");
            std::string pair;
-            pair.reserve((number.size() * 2) + 3);
+            pair.reserve(number.size() * 2 + 3);
            pair += '[';
            pair += number;
            pair += ',';
@@ -0,0 +1,83 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json_view.hpp>
+using nlohmann::json;
+using nlohmann::json_document;
+
+#include <functional>
+#include <map>
+#include <string>
+
+// These tests were split off unit-json_view_compare.cpp, whose object file got
+// too large for the MinGW assembler ("file too big").
+
+namespace
+{
+// an object type that does not enumerate its members in ascending order of keys
+template<typename Key, typename Value, typename /*Compare*/, typename Allocator>
+using descending_object = std::map<Key, Value, std::greater<Key>, Allocator>;
+} // namespace
+
+TEST_CASE("json_view comparison of differing values")
+{
+    SECTION("values that differ in their first bytes, or are written differently")
+    {
+        const auto same = [](const char* x, const char* y)
+        {
+            const json_document dx = json_document::parse(x);
+            const json_document dy = json_document::parse(y);
+            const bool equal = dx.root() == dy.root();
+            CHECK(equal == (json::parse(x) == json::parse(y)));
+            CHECK(equal == (dx.root() == json::parse(y)));
+            const nlohmann::json_editable_document ex = nlohmann::json_editable_document::parse(x);
+            CHECK(equal == (ex.root() == dy.root()));
+            return equal;
+        };
+        // booleans
+        CHECK(!same("true", "false"));
+        CHECK(!same("[true]", "[false]"));
+        CHECK(!same(R"({"a":false,"b":[1]})", R"({"a":true,"b":[1]})"));
+        CHECK(same(R"({"a":true,"b":[1]})", R"({"a":true,"b":[1]})"));
+        // strings and keys of equal length that differ in the first eight bytes (they are compared in words)
+        CHECK(!same(R"("abcdefghijklmnopqrstuvwxyz")", R"("Xbcdefghijklmnopqrstuvwxyz")"));
+        CHECK(!same(R"(["abcdefghijklmnopq",1])", R"(["abcdefghXjklmnopq",1])"));
+        CHECK(!same(R"({"abcdefghijklmnopq":1})", R"({"Xbcdefghijklmnopq":1})"));
+        CHECK(!same(R"({"abcdefghijklmnopq":[1]})", R"({"abcdefghijklmnopX":[1]})"));
+        // floats of one layout and different tokens are the same value
+        CHECK(same("[1.5e0, 2]", "[1.5E0, 2]"));
+        CHECK(same("[1.5e0, 2]", "[1.5e+0, 2]"));
+        CHECK(same("[1.50, 2]", "[1.5, 2]"));
+        CHECK(!same("[1.5e0, 2]", "[1.6e0, 2]"));
+        CHECK(!same("[1.5e0, 2]", "[1.5E1, 2]"));
+        CHECK(same(R"({"a":1.25e0,"b":[3]})", R"({"a":1.25E0,"b":[3]})"));
+    }
+
+    SECTION("a basic_json whose members are not sorted")
+    {
+        // (an object type that is not an ordered map, and does not keep its members sorted either)
+        using descending_json = nlohmann::basic_json<descending_object>;
+        using descending_document = nlohmann::basic_json_document<descending_json>;
+        std::string text = "{";
+        for (char key = 'a'; key <= 'p'; ++key)
+        {
+            text += (key != 'a' ? ",\"" : "\"") + std::string(1, key) + "\":[" + std::to_string(key) + "]";
+        }
+        text += "}";
+        const descending_json j = descending_json::parse(text);
+        const descending_document d = descending_document::parse(text);
+        CHECK(d.root() == j);
+        CHECK(j == d.root());
+        descending_json other = j;
+        other["k"] = 0;
+        CHECK(d.root() != other);
+        CHECK(other != d.root());
+    }
+}
@@ -101,6 +101,10 @@ TEST_CASE("json_view dump")
        CHECK(d.root().dump(0, ' ', false, json_view::number_format::source) == "[\n1.50,\n1E2,\n-0,\n-0.0,\n123456789012345678901234567890,\n18446744073709551615,\n-9223372036854775808,\n0.1,\n1e-7,\n5e-324\n]");
        CHECK(d.root().dump(-1, ' ', true, json_view::number_format::source) == "[1.50,1E2,-0,-0.0,123456789012345678901234567890,18446744073709551615,-9223372036854775808,0.1,1e-7,5e-324]");

+        CHECK(d.root().dump(0, ' ', true, json_view::number_format::source) == d.root().dump(0, ' ', false, json_view::number_format::source));
+        const json_document escaped = json_document::parse("[\"\xC3\xA9\", 1.50, {\"\xF0\x9F\x98\x80\": 1E2}]");
+        CHECK(escaped.root().dump(1, ' ', true, json_view::number_format::source) == "[\n \"\\u00e9\",\n 1.50,\n {\n  \"\\ud83d\\ude00\": 1E2\n }\n]");
+
        // float tokens of up to 17 significant digits in every spelling: those
        // of at most 15 digits are written from their digits, the others
        // through the conversion; both as dump() writes them
@@ -232,6 +236,29 @@ TEST_CASE("json_view dump")
            CHECK(editable.root().dump() == expected.dump());
        }

+        // tokens of 16 and 17 digits with few digits after the point, and with a value of 0, which are
+        // converted by the general algorithm; padded, as a token near the end of the text is not read in this way
+        {
+            const std::string padding(40, ' ');
+            for (const char* token :
+                    {
+                        "123456789012.3456", "-123456789012.3456", "1234567890123.456", "12345678901234.56", "123456789012345.6", "1234567890123456.0",
+                        "0.0000000000000000", "-0.0000000000000000", "0.000000000000000", "1234567890123.4567", "99999999999999.999"
+                    })
+            {
+                CAPTURE(token)
+                const std::string padded = std::string("[") + token + padding + "]";
+                const json_document padded_document = json_document::parse(padded);
+                const json padded_json = json::parse(padded);
+                CHECK(padded_document.root()[0].get<double>() == padded_json[0].get<double>());
+                CHECK(padded_document.root().dump() == padded_json.dump());
+                // a float document converts the tokens as well
+                using json_float = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+                const nlohmann::basic_json_document<json_float> float_doc = nlohmann::basic_json_document<json_float>::parse(padded);
+                CHECK(float_doc.root()[0].get<float>() == json_float::parse(padded)[0].get<float>());
+            }
+        }
+
        // random doubles, written as parse() and dump() would
        std::mt19937_64 rng(1170); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
        std::string many = "[";
@@ -214,6 +214,24 @@ TEST_CASE("json_view dump: escaping, nesting, and output buffers")
        CHECK(d.root()["a"].dump(-1, ' ', true).size() == 2 + (5000 * 6));
    }

+    SECTION("the estimate for a value that is followed by many decoded strings")
+    {
+        // (the end of the value in the source is not known when the nodes after it have decoded strings)
+        std::string text = "[7";
+        for (int i = 0; i < 20; ++i)
+        {
+            text += R"(,"\n")";
+        }
+        text += ",8]";
+        const json_document d = json_document::parse(text);
+        CHECK(d.root()[0].dump() == "7");
+        CHECK(d.root()[1].dump() == R"("\n")");
+        CHECK(d.root().dump() == json::parse(text).dump());
+        // the same with a container
+        const json_document nested = json_document::parse(R"([[7],)" + text.substr(3));
+        CHECK(nested.root()[0].dump() == "[7]");
+    }
+
    SECTION("ensure_ascii with strings of the source, decoded strings, and edited strings")
    {
        // plain ASCII, non-ASCII, escaped (decoded), and mixed strings, as values and as keys;
@@ -259,6 +277,28 @@ TEST_CASE("json_view dump: escaping, nesting, and output buffers")
        }
    }

+    SECTION("the length of the run that ensure_ascii copies")
+    {
+        // (dump() only asks for strings with a byte to escape, so a run that ends the string is checked here)
+        for (const std::size_t length :
+                {
+                    std::size_t{0}, std::size_t{1}, std::size_t{15}, std::size_t{16}, std::size_t{17}, std::size_t{31}, std::size_t{32}, std::size_t{48}, std::size_t{50}
+                })
+        {
+            CAPTURE(length)
+            // a run of printable characters, followed by a byte that is not copied and more text
+            std::string text(length, 'a');
+            text += "\"abcdefghijklmnopqrstuvwxyz";
+            const auto* const bytes = reinterpret_cast<const unsigned char*>(text.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            const auto* const end = bytes + text.size();
+            CHECK(nlohmann::detail::view::ascii_copyable_run(bytes, length, end) == length);
+            CHECK(nlohmann::detail::view::ascii_copyable_run(bytes, length + 1, end) == length);
+            CHECK(nlohmann::detail::view::ascii_copyable_run(bytes, length + 5, end) == length);
+            // the end of the buffer right after the run
+            CHECK(nlohmann::detail::view::ascii_copyable_run(bytes, length, bytes + length) == length);
+        }
+    }
+
    SECTION("ensure_ascii with DEL or a non-ASCII character at every position")
    {
        // the check whether a string of the source has no byte >= 0x7F reads
@@ -547,6 +547,10 @@ TEST_CASE("json_view edits: errors")
    CHECK_THROWS_WITH_AS(d.set(json::json_pointer("/a/01"), 1), "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'", json::parse_error&);
    CHECK_THROWS_WITH_AS(d.set(root, json_editable_view()), "[json.exception.type_error.302] type must be a value, but is discarded", json::type_error&);
    CHECK_THROWS_WITH_AS(d.set(root, json::binary({1, 2})), "[json.exception.type_error.319] cannot store a binary value in a json_document", json::type_error&);
+    CHECK_THROWS_WITH_AS(d.set(root, json(json::value_t::discarded)), "[json.exception.type_error.302] type must be a value, but is discarded", json::type_error&);
+    // (an index that does not fit the document, in a null: basic_json would pad it with 4 Gi nulls)
+    CHECK_THROWS_AS(d.set(json::json_pointer("/z/4294967295"), 1), json::out_of_range&);
+    CHECK(root["z"].is_null());

 #if !defined(JSON_NOEXCEPTION)
    // invalid UTF-8 is rejected when it enters the document, with the error
@@ -572,6 +576,19 @@ TEST_CASE("json_view edits: errors")
    static_cast<void>(other);
 }

+TEST_CASE("json_view edits: a container that was added is replaced by a scalar")
+{
+    // the view of an element that push_back() added is that of the new value itself, not of
+    // the slot that links to it: replacing it by a scalar has to find the container it is in
+    json_editable_document d = json_editable_document::parse(R"({"a": [1]})");
+    d.push_back(d.root()["a"], json::array({2, 3}));
+    d.push_back(d.root()["a"], json::object({{"k", json::array({4, 5})}}));
+    d.set(d.root()["a"][1], 6);
+    d.set(d.root()["a"][2]["k"], "s");
+    CHECK(d.root().dump() == R"({"a":[1,6,{"k":"s"}]})");
+    CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})"));
+}
+
 #if !defined(JSON_NOEXCEPTION)
 TEST_CASE("json_view edits: the size of a text arena")
 {
@@ -277,6 +277,17 @@ TEST_CASE("json_view from_json")
        CHECK(true);
    }

+    SECTION("a map with enum keys from a view that is not an object")
+    {
+        // an object is read with the keys as the enum's names; any other
+        // value is read as an array of pairs, like a map of any other key type
+        const json_document d = json_document::parse(R"({"pairs": [["red", 1], ["green", 2]], "number": 1})");
+        const json j = d.root().materialize();
+        const json_view v = d.root();
+        CHECK(same<std::map<color, int>>(v, j, "pairs"));
+        CHECK((v["pairs"].get<std::map<color, int>>() == std::map<color, int> {{color::red, 1}, {color::green, 2}}));
+    }
+
    SECTION("std types: the same values as from the materialized value")
    {
        const json_document d = json_document::parse(R"({"ints": [3, 1, 2, 1], "strings": ["b", "a", "b"], "pairs": [[1, "x"], [2, "y"]],
@@ -819,6 +819,13 @@ TEST_CASE("json_view images: errors")
            static_cast<void>(d);
        }) == prefix + "too short");

+        // an image that is moved into the document is checked as well
+        CHECK(exception_of([&]
+        {
+            const json_document d = json_document::load(std::vector<std::uint8_t>(10, 0));
+            static_cast<void>(d);
+        }) == prefix + "too short");
+
        std::vector<std::uint8_t> bad = image;
        bad[0] = 'X';
        CHECK(load_result(bad, image_check::full) == prefix + "unknown format");
@@ -333,6 +333,62 @@ TEST_CASE("json_view large objects")
        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
    }

+    SECTION("a lookup of a missing key stops at the end of the probe window")
+    {
+        // Every slot of the first half of the table holds a key, each at its home slot, so
+        // that the table is built; a key that is not in the object but whose home slot is
+        // the first slot finds a full window of slots with other keys.
+        constexpr std::size_t members = 128;
+        constexpr std::size_t table_size = 256; // the table size for 128 members: the next power of two >= 256
+        for (const std::size_t prefix_length :
+                {
+                    std::size_t{0}, std::size_t{20}
+                })
+        {
+            CAPTURE(prefix_length)
+            std::vector<std::string> keys(members);
+            std::vector<bool> taken(members, false);
+            std::string missing;
+            std::size_t found = 0;
+            for (std::uint64_t counter = 0; found < members || missing.empty(); ++counter)
+            {
+                std::string key(prefix_length, 'p');
+                std::uint64_t x = counter;
+                for (std::size_t i = 0; i < 8; ++i, x /= 26)
+                {
+                    key += static_cast<char>('a' + (x % 26));
+                }
+                const std::size_t slot = nlohmann::detail::conditional_static_cast<std::size_t>(nlohmann::detail::view::key_hash(key.data(), key.size())) & (table_size - 1);
+                if (slot < members && !taken[slot])
+                {
+                    taken[slot] = true;
+                    keys[slot] = key;
+                    ++found;
+                }
+                else if (slot == 0 && missing.empty())
+                {
+                    missing = key;
+                }
+            }
+            std::string text = "{";
+            for (std::size_t i = 0; i < members; ++i)
+            {
+                text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i);
+            }
+            text += "}";
+            const json_document d = json_document::parse(text);
+            const json_view v = d.root();
+            for (std::size_t i = 0; i < members; ++i)
+            {
+                CAPTURE(i)
+                CHECK(v[keys[i]].get<std::size_t>() == i);
+            }
+            CHECK(!v.contains(missing));
+            CHECK(v.find(missing) == v.end());
+            CHECK(v.count(missing) == 0);
+        }
+    }
+
    SECTION("keys that differ in their last bytes are spread over the table")
    {
        // The hash must spread the usual families of keys (numbered names, hex
@@ -20,6 +20,7 @@ using nlohmann::ordered_json;
 using nlohmann::json_document;
 using nlohmann::json_editable_document;

+#include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
@@ -427,6 +428,31 @@ TEST_CASE("json_view materialize() source positions")
            CHECK(same_positions(m[std::string("a") + '\n'][2], j[std::string("a") + '\n'][2]));
        }

+        SECTION("a damaged text: the end of a container is not found")
+        {
+            // (the text of an image is not checked with image_check::none)
+            const std::string array_text = "[1,2]";
+            const std::vector<std::uint8_t> original = json_document::parse(array_text).save();
+            const auto at = std::search(original.begin(), original.end(), array_text.begin(), array_text.end());
+            REQUIRE(at != original.end());
+            const auto closing = static_cast<std::size_t>(at - original.begin()) + array_text.size() - 1;
+            // not a closing bracket, a slash that starts no comment, and the end of the text
+            for (const char replacement :
+                    {
+                        'x', '/', ' '
+                    })
+            {
+                CAPTURE(replacement)
+                std::vector<std::uint8_t> damaged = original;
+                damaged[closing] = static_cast<std::uint8_t>(replacement);
+                const json_document d = json_document::load(damaged, json_document::image_check::none);
+                const json m = d.root().materialize();
+                CHECK(range(m) == "none");
+                CHECK(range(m[0]) == "1-2");
+                CHECK(range(m[1]) == "3-4");
+            }
+        }
+
 #if !defined(JSON_NOEXCEPTION)
        SECTION("a decoded string's position must be within the text")
        {
@@ -461,6 +487,7 @@ TEST_CASE("json_view exceptions name the path and the bytes of the value")
        {
            "null", "true", "42", "\"s\"", "[]", "{}", "[1, [2, [3, []]]]", R"({"a": {"b": [1, {"c": null}]}, "d": "e"})",
            R"({"a/b": {"~": [1]}, "\u0041\n": {"x": "\t"}, "": [{}]})",
+            R"({"a\u0000b": [1, "x"], "c": {"d\u0000": 2}})", // (the path of a key ends at a null byte, as in basic_json)
            R"([1 /* ] */, {"a": [] // }
 , "b": {} } , ])",
            "\n\t[\r\n  1 ,\n  {\n    \"a\" : [ ]\n  }\n]\n",
@@ -512,6 +539,49 @@ TEST_CASE("json_view exceptions name the path and the bytes of the value")
        CHECK(exception_of_call([&] { static_cast<void>(d.root()["a"][2]["n"][0].get<int>()); }) == expected);
    }

+    SECTION("views of values that are no longer part of the document, and of no value")
+    {
+        const std::string expected_string = "[json.exception.type_error.302] type must be number, but is string";
+        static_cast<void>(expected_string);
+        // (a value that is not found has no path, and with it no bytes)
+        {
+            json_editable_document d = json_editable_document::parse(R"(["x", ["y"]])");
+            const auto removed = d.root()[0];
+            d.erase(d.root(), 0);
+#if JSON_DIAGNOSTICS
+            CHECK(exception_of_call([&] { static_cast<void>(removed.get<int>()); }) == expected_string);
+#endif
+            // (the root is a scalar now: the value cannot be in it)
+            d.set(d.root(), 5);
+#if JSON_DIAGNOSTICS
+            CHECK(exception_of_call([&] { static_cast<void>(removed.get<int>()); }) == expected_string);
+#endif
+            CHECK(d.root().get<int>() == 5);
+        }
+        {
+            json_editable_document d = json_editable_document::parse(R"(["x"])");
+            const auto removed = d.root()[0];
+            d.set(d.root(), 5);
+#if JSON_DIAGNOSTICS
+            CHECK(exception_of_call([&] { static_cast<void>(removed.get<int>()); }) == expected_string);
+#endif
+        }
+        // a view of no value has no context
+        CHECK(exception_of_call([&] { static_cast<void>(nlohmann::json_view().get<int>()); }) == "[json.exception.type_error.302] type must be number, but is discarded");
+    }
+
+    SECTION("an array whose last element was replaced by a new container has no bytes")
+    {
+        json_editable_document d = json_editable_document::parse(R"({"a": [1, [2]], "b": 1})");
+        d.set(d.root()["a"][1], json::array({3}));
+        std::string expected = "[json.exception.type_error.302] ";
+#if JSON_DIAGNOSTICS
+        expected += "(/a) ";
+#endif
+        expected += "type must be number, but is array";
+        CHECK(exception_of_call([&] { static_cast<void>(d.root()["a"].get<int>()); }) == expected);
+    }
+
    SECTION("deep documents with siblings after every nested container")
    {
        // the search for the path pushes and pops one frame per level (the
@@ -521,8 +591,7 @@ TEST_CASE("json_view exceptions name the path and the bytes of the value")
        std::string text = "7";
        for (int level = 0; level < 40; ++level)
        {
-            text.insert(0, R"([[1, [2]], )");
-            text += R"(, {"k": [3, {"l": [4]}]}, [5, [6, [7]]]])";
+            text = R"([[1, [2]], )" + text + R"(, {"k": [3, {"l": [4]}]}, [5, [6, [7]]]])";
        }
        CAPTURE(text)
        const json j = json::parse(text);
@@ -12,7 +12,10 @@
 using nlohmann::json;

 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <utility>

 TEST_CASE("tests on very large JSONs")
 {
@@ -140,6 +143,56 @@ TEST_CASE("tests on deeply nested JSONs")
            }
        }

+        SECTION("leaf values of every type below the bound of the recursive descent")
+        {
+            // the elements and members of the containers below the bound are
+            // copied one by one, whatever their type
+            const json leaves = json::array(
+            {
+                nullptr, true, false, -1, std::uint64_t{1}, 1.5, "text", json::binary({1, 2, 3})
+            });
+            const json members =
+            {
+                {"null", nullptr}, {"boolean", true}, {"integer", -1}, {"unsigned", std::uint64_t{1}},
+                {"float", 1.5}, {"string", "text"}, {"binary", json::binary({1, 2, 3})}
+            };
+
+            for (const bool objects :
+                    {
+                        false, true
+                    })
+            {
+                CAPTURE(objects)
+
+                json j = objects ? members : leaves;
+                for (std::size_t i = 0; i < 300; ++i)
+                {
+                    json wrapper = objects ? json::object() : json::array();
+                    if (objects)
+                    {
+                        wrapper["a"] = std::move(j);
+                    }
+                    else
+                    {
+                        wrapper.push_back(std::move(j));
+                    }
+                    j = std::move(wrapper);
+                }
+
+                const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
+
+                const json* current = &copy;
+                for (std::size_t i = 0; i < 300; ++i)
+                {
+                    current = objects ? &current->at("a") : &current->front();
+                }
+
+                // the innermost value is shallow: it is safe to compare
+                CHECK(*current == (objects ? members : leaves));
+                CHECK(current->size() == (objects ? members.size() : leaves.size()));
+            }
+        }
+
        SECTION("a value that is deep in one place only")
        {
            json j = json::object();
@@ -495,3 +495,206 @@ TEST_CASE("locale changes during a single dump() (#5709 item 3)")
    // fix #5597 made on the parser side
    CHECK(buf.data == "[\"" + padding + "\",1234.5]");
 }
+
+namespace
+{
+// a token whose first data() call switches LC_NUMERIC, so that the locale
+// changes between convert_float_locale_aware() looking up the decimal point
+// and strtod reading the token (the race of #5198, made deterministic)
+struct locale_switching_token
+{
+    using value_type = char;
+
+    locale_switching_token(std::string text_, const char* switch_to_)
+        : text(std::move(text_)), switch_to(switch_to_)
+    {}
+
+    std::size_t size() const
+    {
+        return text.size();
+    }
+
+    char& operator[](std::size_t i)
+    {
+        return text[i];
+    }
+
+    char* data()
+    {
+        if (!switched)
+        {
+            switched = std::setlocale(LC_NUMERIC, switch_to) != nullptr;
+        }
+        return &text[0];
+    }
+
+    std::string text;
+    const char* switch_to;
+    bool switched = false;
+};
+
+// set LC_NUMERIC to the first of @a names that is usable and has a decimal
+// point of @a min_size bytes at least (and at most @a max_size)
+bool use_decimal_point_locale(const std::vector<const char*>& names, std::size_t min_size, std::size_t max_size, const char*& used)
+{
+    for (const char* name : names)
+    {
+        if (std::setlocale(LC_NUMERIC, name) == nullptr)
+        {
+            continue;
+        }
+        const std::size_t size = std::string(std::localeconv()->decimal_point).size();
+        if (size >= min_size && size <= max_size)
+        {
+            used = name;
+            return true;
+        }
+    }
+    return false;
+}
+
+// convert a token with convert_float_locale_aware(); the token must be given
+// back as it was
+template<typename FloatType>
+FloatType convert_locale_aware(const std::string& text)
+{
+    std::string token = text;
+    const std::size_t dot = token.find('.');
+    FloatType value{};
+    nlohmann::detail::convert_float_locale_aware(token, dot, value);
+    CHECK(token == text);
+    return value;
+}
+
+template<typename FloatType>
+void check_locale_aware_conversions()
+{
+    CHECK(convert_locale_aware<FloatType>("3.5") == FloatType(3.5));
+    CHECK(convert_locale_aware<FloatType>("-0.25") == FloatType(-0.25));
+    CHECK(convert_locale_aware<FloatType>("1.25e2") == FloatType(125));
+    // no decimal point at all
+    CHECK(convert_locale_aware<FloatType>("12e1") == FloatType(120));
+    CHECK(convert_locale_aware<FloatType>("7") == FloatType(7));
+}
+} // namespace
+
+TEST_CASE("convert_float_locale_aware")
+{
+    const std::vector<const char*> single_byte_names = {"de_DE.UTF-8", "de_DE", "fr_FR.UTF-8", "fr_FR", "ru_RU.UTF-8"};
+    const std::vector<const char*> multi_byte_names = {"ar_EG.UTF-8", "ar_SA.UTF-8", "fa_IR.UTF-8", "ps_AF.UTF-8", "ar_EG", "fa_IR"};
+    const char* used = nullptr;
+
+    SECTION("decimal point '.'")
+    {
+        REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+        check_locale_aware_conversions<float>();
+        check_locale_aware_conversions<double>();
+        check_locale_aware_conversions<long double>();
+    }
+
+    SECTION("single-byte decimal point other than '.'")
+    {
+        if (use_decimal_point_locale(single_byte_names, 1, 1, used) && std::localeconv()->decimal_point[0] != '.')
+        {
+            CAPTURE(used)
+            check_locale_aware_conversions<float>();
+            check_locale_aware_conversions<double>();
+            check_locale_aware_conversions<long double>();
+        }
+        else
+        {
+            MESSAGE("no locale with a single-byte decimal point other than '.' is usable");
+        }
+    }
+
+    SECTION("multi-byte decimal point")
+    {
+        if (use_decimal_point_locale(multi_byte_names, 2, 8, used))
+        {
+            CAPTURE(used)
+            check_locale_aware_conversions<float>();
+            check_locale_aware_conversions<double>();
+            check_locale_aware_conversions<long double>();
+        }
+        else
+        {
+            MESSAGE("no locale with a multi-byte decimal point is usable");
+        }
+    }
+
+    SECTION("a token that is not converted completely")
+    {
+        // the locale does not change, so there is nothing to retry: the
+        // value up to the garbage is kept
+        REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+        std::string token = "1.5x";
+        double value = 0;
+        nlohmann::detail::convert_float_locale_aware(token, token.find('.'), value);
+        CHECK(value == 1.5);
+        CHECK(token == "1.5x");
+    }
+
+    SECTION("the locale changes before the conversion")
+    {
+        if (!use_decimal_point_locale(single_byte_names, 1, 1, used) || std::localeconv()->decimal_point[0] == '.')
+        {
+            MESSAGE("no locale with a single-byte decimal point other than '.' is usable");
+        }
+        else
+        {
+            const std::string comma_locale = used;
+            REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+
+            // "C" -> comma locale: strtod stops at the '.', so the conversion is repeated
+            {
+                locale_switching_token token("1.5", comma_locale.c_str());
+                double value = 0;
+                nlohmann::detail::convert_float_locale_aware(token, 1, value);
+                if (token.switched)
+                {
+                    CHECK(value == 1.5);
+                    CHECK(token.text == "1.5");
+                }
+            }
+
+            // the same for the other floating-point types
+            REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+            {
+                locale_switching_token token("2.25", comma_locale.c_str());
+                float value = 0;
+                nlohmann::detail::convert_float_locale_aware(token, 1, value);
+                if (token.switched)
+                {
+                    CHECK(value == 2.25f);
+                }
+            }
+            REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+            {
+                locale_switching_token token("2.25", comma_locale.c_str());
+                long double value = 0;
+                nlohmann::detail::convert_float_locale_aware(token, 1, value);
+                if (token.switched)
+                {
+                    CHECK(value == 2.25L);
+                }
+            }
+
+            // comma locale -> multi-byte decimal point
+            const char* multi_byte = nullptr;
+            if (use_decimal_point_locale(multi_byte_names, 2, 8, multi_byte))
+            {
+                REQUIRE(std::setlocale(LC_NUMERIC, comma_locale.c_str()) != nullptr);
+                locale_switching_token token("1.5", multi_byte);
+                double value = 0;
+                nlohmann::detail::convert_float_locale_aware(token, 1, value);
+                if (token.switched)
+                {
+                    CHECK(value == 1.5);
+                    CHECK(token.text == "1.5");
+                }
+            }
+        }
+    }
+
+    CHECK(std::setlocale(LC_NUMERIC, "C") != nullptr);
+}
@@ -18,6 +18,7 @@ using nlohmann::json;

 #ifdef JSON_HAS_CPP_17
 #include <cstddef>
+#include <string>
 #include <vector>

 // Test suite for verifying MessagePack handling with std::byte input
@@ -96,4 +97,33 @@ TEST_CASE("MessagePack with std::byte")
        }
    }
 }
+
+// JSON text (not MessagePack) as std::byte input: the error position is
+// computed from the bytes consumed so far
+TEST_CASE("JSON text with std::byte")
+{
+    const auto to_bytes = [](const std::string & text)
+    {
+        std::vector<std::byte> bytes;
+        for (const char c : text)
+        {
+            bytes.push_back(static_cast<std::byte>(c));
+        }
+        return bytes;
+    };
+
+    SECTION("valid text")
+    {
+        const json j = json::parse(to_bytes("[1,\n2]"));
+        CHECK(j == json({1, 2}));
+        CHECK(json::accept(to_bytes("[1,\n2]")));
+    }
+
+    SECTION("invalid text")
+    {
+        CHECK_FALSE(json::accept(to_bytes("[1,\n2,")));
+        CHECK_THROWS_WITH_AS(json::parse(to_bytes("[1,\n2,")),
+                             "[json.exception.parse_error.101] parse error at line 2, column 3: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal", json::parse_error&);
+    }
+}
 #endif
@@ -16,6 +16,7 @@ using nlohmann::ordered_json;
 #include <cstddef>
 #include <cstdint>
 #include <string>
+#include <vector>

 TEST_CASE("ordered_json")
 {
@@ -515,3 +516,87 @@ TEST_CASE("parsing random trees of arrays and objects")
        CHECK(json::parse(text).dump() == expected.dump());
    }
 }
+
+TEST_CASE("object_key_index")
+{
+    // the hash table of the DOM parser finds the position of a key in an
+    // ordered_json object; the parser creates it for exactly 64 elements, but
+    // it is correct for any number of elements it is given
+    using nlohmann::detail::object_key_index;
+    const std::size_t not_found = object_key_index::npos;
+
+    for (const std::size_t initial :
+            {
+                std::size_t{0}, std::size_t{10}, std::size_t{64}, std::size_t{65}, std::size_t{300}
+            })
+    {
+        CAPTURE(initial)
+
+        // the hashes are not distinct on purpose: elements with the same
+        // hash are told apart by the caller
+        const auto hash_of = [](std::size_t position)
+        {
+            return (position % 50) * 0x9E3779B97F4A7C15ull;
+        };
+
+        std::vector<std::size_t> hashes;
+        for (std::size_t i = 0; i < initial; ++i)
+        {
+            hashes.push_back(hash_of(i));
+        }
+        object_key_index index(std::move(hashes));
+
+        // the elements that are there
+        for (std::size_t i = 0; i < initial; ++i)
+        {
+            CHECK(index.find(hash_of(i), [i](std::size_t position)
+            {
+                return position == i;
+            }) == i);
+        }
+        CHECK(index.find(hash_of(1), [](std::size_t /*position*/)
+        {
+            return false;
+        }) == not_found);
+
+        // elements that are added later, until the table grows
+        for (std::size_t i = initial; i < initial + 600; ++i)
+        {
+            index.add(hash_of(i));
+            CHECK(index.find(hash_of(i), [i](std::size_t position)
+            {
+                return position == i;
+            }) == i);
+        }
+        CHECK(index.find(hash_of(initial), [initial](std::size_t position)
+        {
+            return position == initial;
+        }) == initial);
+    }
+}
+
+TEST_CASE("JSON pointers on ordered_json")
+{
+    using pointer = ordered_json::json_pointer;
+
+    SECTION("operator[] inserts a missing key at the end")
+    {
+        ordered_json j = {{"z", 1}, {"x", {{"y", 2}}}};
+
+        j[pointer("/a")] = 3;
+        j[pointer("/x/b")] = 4;
+
+        CHECK(j == ordered_json({{"z", 1}, {"x", {{"y", 2}, {"b", 4}}}, {"a", 3}}));
+        CHECK(j.dump() == R"({"z":1,"x":{"y":2,"b":4},"a":3})");
+    }
+
+    SECTION("unflatten of a flattened object whose keys are not sorted")
+    {
+        // the prefixes /a and /c denote arrays; a key of /a follows one of /c
+        const ordered_json flat = {{"/a/0/p", 1}, {"/c/0/x", 2}, {"/a/0/q", 3}, {"/a/1/p", 4}};
+        const ordered_json expected = {{"a", {{{"p", 1}, {"q", 3}}, {{"p", 4}}}}, {"c", {{{"x", 2}}}}};
+
+        CHECK(flat.unflatten() == expected);
+        CHECK(expected.flatten().unflatten() == expected);
+    }
+}
@@ -23,11 +23,13 @@ using nlohmann::json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif

+#include <array>
 #include <fstream>
 #include <sstream>
 #include <list>
 #include <limits>
 #include <cstdio>
+#include <utility>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"

@@ -1519,6 +1521,75 @@ TEST_CASE("regression tests 1")
        }
    }

+    SECTION("operator[](json_pointer) continues with the member that emplace() found")
+    {
+        // see the section above: the lookup does not find "k", but emplace()
+        // finds "x" and the pointer continues with the member of "x". Here
+        // the member is a container, so the pointer can go on below it. Only
+        // the outermost object may be a copy (with restarted timestamps): the
+        // value of "x" is moved in, so that its own lookups work.
+        const my_json orig = my_json::parse(R"({"x":null})");
+        const auto make = [&orig]()
+        {
+            my_json::object_t top = orig.get_ref<const my_json::object_t&>();
+            top.at("x") = my_json::parse(R"({"a":{"b":1},"n":null,"arr":[10,20],"objs":[{"m":5},{"m":6}]})");
+            return my_json(std::move(top));
+        };
+
+        SECTION("existing members")
+        {
+            // emplace() registers the key "k" in the object, so that every
+            // pointer needs a new object to reach the member of "x" again
+            const std::array<std::pair<const char*, const char*>, 4> pointers = {{{"/k/a/b", "1"}, {"/k/arr/1", "20"}, {"/k/n", "null"}, {"/k/objs/1/m", "6"}}};
+            for (const auto& pointer : pointers)
+            {
+                CAPTURE(pointer.first)
+                my_json j = make();
+                CHECK(j[my_json::json_pointer(pointer.first)].dump() == pointer.second);
+                CHECK(j.size() == 1);
+                CHECK(j["x"].size() == 4);
+            }
+        }
+
+        SECTION("a missing member of an object")
+        {
+            my_json j = make();
+#ifdef JSON_NO_THREAD_LOCAL
+            // the objects below the outermost one are not copied by their
+            // object_t here, but member by member, which keeps their
+            // timestamps correct: "c" is not mistaken for "b" and is inserted
+            CHECK(j[my_json::json_pointer("/k/a/c/d")].is_null());
+            CHECK(j["x"]["a"].dump() == R"({"b":1,"c":{"d":null}})");
+#else
+            // the timestamp of "c" is that of "b" again, so that emplace()
+            // finds the member "b", a number, which has no member "d"
+            CHECK_THROWS_AS(j[my_json::json_pointer("/k/a/c/d")], my_json::out_of_range&);
+            CHECK(j["x"]["a"].dump() == R"({"b":1})");
+#endif
+        }
+
+        SECTION("a null value is converted to an object")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/n/c")] = 3;
+            CHECK(j["x"]["n"].dump() == R"({"c":3})");
+        }
+
+        SECTION("the end of an array")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/arr/-")] = 30;
+            CHECK(j["x"]["arr"].dump() == "[10,20,30]");
+        }
+
+        SECTION("an index past the end of an array")
+        {
+            my_json j = make();
+            j[my_json::json_pointer("/k/arr/3")] = 40;
+            CHECK(j["x"]["arr"].dump() == "[10,20,null,40]");
+        }
+    }
+
    SECTION("issue #977 - Assigning between different json types")
    {
        foo_json lj = ns::foo{3};
@@ -441,6 +441,10 @@ TEST_CASE("regression tests 2")

        float_json j2 = {1000.0, 2000.0, 3000.0};
        CHECK(float_json::from_ubjson(float_json::to_ubjson(j2, true, true)) == j2);
+
+        // half-precision floats of both signs are converted to the float type
+        CHECK(float_json::from_cbor(std::vector<std::uint8_t> {0xF9, 0xC0, 0x00}) == -2.0f);
+        CHECK(float_json::from_cbor(std::vector<std::uint8_t> {0xF9, 0x3C, 0x00}) == 1.0f);
    }

    SECTION("issue #1045 - Using STL algorithms with JSON containers with expected results?")
@@ -19,11 +19,13 @@
 using nlohmann::json;

 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <fstream>
 #include <istream>
+#include <limits>
 #include <random>
 #include <sstream>
 #include <streambuf>
@@ -93,6 +95,33 @@ class chunked_streambuf : public std::streambuf
    std::size_t m_unbuffered;
 };

+#if TEST_STREAM_BULK_SCAN
+// A streambuf that claims a get area of several gigabytes, of which only the
+// first bytes exist. It is only used to move the read position of the adapter,
+// never to read beyond them, so that skipping more than gbump() can bump at
+// once can be tested without allocating that much.
+class oversized_get_area_streambuf : public std::streambuf
+{
+  public:
+    explicit oversized_get_area_streambuf(std::size_t claimed_size)
+    {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+        setg(m_data.data(), m_data.data(), m_data.data() + claimed_size);
+    }
+
+    // Give the get area back its real size, so that the adapter may read the
+    // character at the read position when it is destroyed (with
+    // JSON_PRECISE_STREAM_POSITION, it consumes the last character returned).
+    void restore_get_area()
+    {
+        setg(m_data.data(), m_data.data(), m_data.data() + m_data.size());
+    }
+
+  private:
+    std::array<char, 8> m_data{{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}};
+};
+#endif
+
 // how a test reads from the stream
 enum class read_mode
 {
@@ -433,6 +462,35 @@ TEST_CASE("parsing from a std::istream scans the get area in bulk")
        ia.copy_token(token, false);
        CHECK(token.empty());
    }
+
+    SECTION("skipping more characters than gbump() takes at once")
+    {
+        // gbump() takes an int, but a get area can be larger
+        const std::size_t claimed = sizeof(std::size_t) < 8 ? 0 : std::size_t{3} << 30u;
+        oversized_get_area_streambuf buf(claimed);
+        if (claimed == 0 || static_cast<std::size_t>(buf.in_avail()) != claimed)
+        {
+            // a 32-bit size_t, or a standard library whose streambuf stores
+            // the size of the get area in an int (MSVC)
+            MESSAGE("a get area larger than an int is not supported");
+        }
+        else
+        {
+            std::istream is(&buf);
+            nlohmann::detail::input_stream_adapter ia(is);
+            CHECK(ia.get_character() == 'a');
+            CHECK(ia.bulk_remaining() == claimed - 1);
+
+            const std::size_t skipped = static_cast<std::size_t>((std::numeric_limits<int>::max)()) + 10;
+            ia.bulk_skip(skipped);
+            CHECK(ia.bulk_remaining() == claimed - 1 - skipped);
+
+            ia.bulk_skip(ia.bulk_remaining());
+            CHECK(ia.bulk_remaining() == 0);
+
+            buf.restore_get_area();
+        }
+    }
 #endif

    SECTION("SAX parsing from a stream")
@@ -928,3 +928,49 @@ TEST_CASE("short decimals")
        }
    }
 }
+
+TEST_CASE("decimals of up to 17 digits")
+{
+    // write_decimal() lays out digits * 10^exp as format_buffer() does; to_chars()
+    // calls it for the doubles whose digits write_shortest() does not convert at
+    // once, and the digits may be as many as 17
+    const auto written = [](std::uint64_t digits, int exp) -> std::string
+    {
+        std::array<char, 64> buf{}; // (up to 41 bytes are written)
+        char* const end = nlohmann::detail::dtoa_impl::write_decimal(buf.data(), digits, exp);
+        return {buf.data(), end};
+    };
+
+    SECTION("fixed notation")
+    {
+        CHECK(written(1, 0) == "1.0");
+        CHECK(written(1234, -2) == "12.34");
+        CHECK(written(123, 2) == "12300.0");
+        CHECK(written(50000000000u, -1) == "5000000000.0");
+        CHECK(written(100000000u, -8) == "1.0");
+        CHECK(written(12345678u, -12) == "1.2345678e-05");
+        CHECK(written(1234, 11) == "123400000000000.0");
+        // the point moves left of the first digit
+        CHECK(written(5, -3) == "0.005");
+        CHECK(written(12345678901234567u, -20) == "0.00012345678901234567");
+    }
+
+    SECTION("exponent notation")
+    {
+        CHECK(written(5, -5) == "5e-05");
+        CHECK(written(1234, 12) == "1.234e+15");
+        CHECK(written(5, -324) == "5e-324");
+    }
+
+    SECTION("17 digits")
+    {
+        CHECK(written(12345678901234567u, -16) == "1.2345678901234567");
+        CHECK(written(12345678901234567u, -19) == "0.0012345678901234567");
+        CHECK(written(12345678901234567u, 5) == "1.2345678901234567e+21");
+        CHECK(written(99999999999999999u, -17) == "0.99999999999999999");
+        CHECK(written(10000000000000001u, -16) == "1.0000000000000001");
+        // trailing zeros are not written
+        CHECK(written(10000000000000000u, -17) == "0.1");
+        CHECK(written(12000000000000000u, -15) == "12.0");
+    }
+}
@@ -1673,6 +1673,31 @@ TEST_CASE("UBJSON")
                    return true;
                });
                CHECK_THROWS_AS(scp2.start_array((std::numeric_limits<std::size_t>::max)() - 1), json::out_of_range&);
+
+                // without exceptions, the error is reported to the caller
+                json l;
+                nlohmann::detail::json_sax_dom_callback_parser<json, decltype(nlohmann::detail::input_adapter(v_ubjson))> scp3(l, [](int /*unused*/, json::parse_event_t /*unused*/, const json& /*unused*/) noexcept
+                {
+                    return true;
+                }, false);
+                CHECK_FALSE(scp3.start_array((std::numeric_limits<std::size_t>::max)() - 1));
+                CHECK(scp3.is_errored());
+            }
+
+            SECTION("array with a known size, read without exceptions")
+            {
+                std::vector<uint8_t> const v_ubjson = {'[', '#', 'i', 2, 'i', 1, 'i', 2};
+                json j;
+                nlohmann::detail::json_sax_dom_parser<json, decltype(nlohmann::detail::input_adapter(v_ubjson))> sax(j, false);
+                CHECK(json::sax_parse(v_ubjson, &sax, json::input_format_t::ubjson));
+                CHECK(j == json({1, 2}));
+
+                // the readers reject a size this large before they announce
+                // it, so it can only reach start_array() directly
+                json k;
+                nlohmann::detail::json_sax_dom_parser<json, decltype(nlohmann::detail::input_adapter(v_ubjson))> sax2(k, false);
+                CHECK_FALSE(sax2.start_array((std::numeric_limits<std::size_t>::max)() - 1));
+                CHECK(sax2.is_errored());
            }
        }
    }
Author	SHA1	Message	Date
Niels Lohmann	73b0a3aba3	Drop the null_result parameter JSON_IMPLEMENT_OPERATOR no longer uses Without the same-type scalar cases, the macro body has no use for it, and JSON_IMPLEMENT_SCALAR_CASES is now used only by JSON_IMPLEMENT_SCALAR_FAST. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-02 10:05:55 +01:00
Niels Lohmann	7196bc5b22	iter_impl: keep the type-dependent initialization in the constructor The check is not needed for correctness (m_it is value-initialized), but without it GCC 13 generates slower iteration loops: a recursive walk over a parsed document takes 0.5-2.7 % longer (callgrind: +1.9 % instructions on twitter.json, +0.95 % on canada.json). Clang generates identical code either way. See the measurements in #6005. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-02 10:05:54 +01:00
Niels Lohmann	2ac0851157	basic_json, iterators, serializer: remove checks that invariants make dead Branch coverage of the test suite and of 24k mutated inputs showed these conditions as never taken; each is implied by the code around it: - copy_object_level(): `src_it != src_object.cend()`; dst was built from exactly src_object.size() unique keys and src_it advances at most once per member - the general comparison operators (equal_general, less_general, three_way_general): the five same-type scalar cases, which the inline fast path of every operator handles before calling them (now an assert); and the NaN half of compares_unordered() in the mixed-type branch, reached only after all six number pairs returned, where only a discarded operand is unordered - serializer, ensure_ascii: the reset of `bytes` under error_handler_t::keep and the surrogate-pair escape in the UTF8_ACCEPT case; every well-formed multi-byte character is escaped by write_u_escapes() before decode() sees it, so decode() only ever accepts DEL here, a single byte of which nothing was buffered (now asserts) - iter_impl(pointer): the if/else chain assigned value-initialized iterators to the value-initialized m_it No change in behaviour: a build that aborts on each removed side passes the test suite, the fuzz corpora and 23.2M dumps of all 1-, 2- and boundary 4-byte strings in both ensure_ascii modes. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-02 09:41:01 +01:00
Niels Lohmann	f093573828	Lexer, parser, stream adapter, SAX: remove checks that invariants make dead Branch coverage of the test suite and of 24k mutated inputs showed these conditions as never taken; each is implied by the code around it: - lexer: `next_unget` in get_codepoint_bulk() and scan_literal_bulk(). unget() is only called at the end of scan_number(), in scan_comment() and in skip_bom(); every token scan starts with a plain get() in skip_whitespace() that consumes a pending unget, and nothing between that get() and the bulk helpers ungets (now asserts, as in get_after_string_run()) - lexer: `number_type == value_integer` in convert_integer(): both callers exclude value_float and the type has three values - parser: `!context.empty()` in exception_message(): all callers pass a literal - input_stream_adapter: `refill` in get_character_slow(): the function is only called after get_character() found the get area exhausted, and the variable recomputed that comparison - json_sax_dom_callback_parser: `ref_stack.back()` in key() (the null case returned a few lines earlier, and the callback in between cannot reach ref_stack), `is_structured()` in end_object() (non-null entries are only pushed for objects and arrays), `!key_stack.empty()` in current_key() (a kept object pushed its key before any value) No change in behaviour: a build that aborts on each removed side passes the test suite, the fuzz corpora and 40k random documents through every input adapter in four macro configurations. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-02 09:41:00 +01:00
Claude	2301f01284	Fix test failures in the coverage tests - unit-custom-object-key-type: remove the unused make_strict_key(strict_key) overload, the unused range constructor and default constructor, and guard data() with JSON_DIAGNOSTICS (unused-function/-member-function errors with GCC and clang -Weverything). - unit-json_view_compare: move the two new sections to the new unit-json_view_compare_values.cpp, as the object file got too large for the MinGW assembler again, and use a std::map with std::greater instead of std::unordered_map, which does not accept the incomplete basic_json (clang 3.9, icpc). - unit-json_view_dump: rename the variables that hid outer ones (MSVC C4456). - unit-stream-bulk-scan: restore the real size of the oversized get area before the adapter is destroyed (JSON_PRECISE_STREAM_POSITION reads the character at the read position), and skip the test where the streambuf cannot hold a get area larger than an int (MSVC). - unit-regression1: with JSON_NO_THREAD_LOCAL, copies are built member by member and keep correct timestamps, so check the corresponding outcome. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01N5NasAgbDGG28MqXjQvLqp Signed-off-by: Claude <noreply@anthropic.com>	2026-11-02 05:59:57 +00:00
Niels Lohmann	056ba3b7c1	Tests: cover the remaining lines of the library headers Add tests for the lines of include/nlohmann that were not covered: the binary readers and writers, the lexer and locale paths, the json_view modules, the custom number, key and array types, json_pointer, json_patch, diff and the iterators. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-01 22:32:42 +01:00
Niels Lohmann	d7b9472173	Remove unreachable code found by the coverage analysis Remove code that no input can reach, and mark the lines that cannot be covered with LCOV_EXCL_LINE: - BJData writer: the dry_run parameter of the ND-array element writers was always true; replace them by range checks. - BON8 writer: call throw_integer_out_of_range() directly instead of write_bon8_value() for values that always throw. - binary_writer: integer_bits() is only called for integers of up to 64 bits. - serializer, view serializer, lexer: replace guards that the callers make unreachable by assertions or by the simpler code (surrogate pairs under ensure_ascii, next_unget, '-' at the end of the buffer). - json_view: drop unreachable branches in scalar(), set(), check_utf8_scan(), append_input_impl() and unescape(). - Mark exception-cleanup braces, 2 GiB limits, big-endian and 32-bit code, and fall-through case labels with LCOV_EXCL_LINE. No behavior changes for any input that reaches these functions. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-01 22:32:41 +01:00
Niels Lohmann	04a5accfb9	CI: measure line coverage without lcov's unexecuted-block adjustment Drop geninfo_unexecuted_blocks=1 from the lcov capture of ci_test_coverage: it reset every line of an inlined or templated function to 0 as soon as one copy had an unexecuted block, which understated the line coverage by about three points. Add -fvar-tracking-assignments to both coverage builds. At -O0, GCC inlines always_inline functions before it places the coverage counters, so the call sites of such helpers (put_literal() and others) got no line record and showed as 0 in an -O3 translation unit that never reaches them. With the flag, the call sites carry counts in every translation unit. The generated code is identical. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-11-01 22:32:40 +01:00