Read CBOR containers and tags without recursing per nesting level

get_cbor_array() and get_cbor_object() read their elements by calling back into the value reader, which called them again for a nested container, and a tag was handled by reading the tagged value the same way. All three cost native stack, and all three cost a single byte to encode: 0x9F opens an indefinite-length array, 0x81 a one-element array, and 0xC2 is a tag. Half a million of any of them crashes the process before the input runs out (#5104). Apply the shape the MessagePack reader already uses: the open containers live on the heap stack, parse_cbor_value() reads a single value and only opens a container rather than reading it to its end, and parse_cbor_internal() loops, resuming the innermost container after each element. Two things are specific to CBOR. An indefinite-length container ends at a break marker rather than at a count, and testing for that marker consumes a byte which is the first byte of the next element when it is not one; the frame's count is npos for those, and the driver tracks whether the next value starts at a fresh byte. And a tag is not a value of its own: instead of reading the tagged value by recursing, the value reader reports that a tag was read and the driver reads on, so a chain of tags costs no stack at all. The switch that decodes a value is unchanged apart from the twelve container cases and the two tag sites. Verified against the previous commit over definite and indefinite arrays and maps, all four counted forms, empty containers, nesting of the forms inside each other, truncated inputs, and all three tag handlers: identical values, error codes, messages and byte offsets. 500,000 levels of each of the three vectors now report parse_error.110 instead of crashing, and a well-formed 200,000-level value is read to completion. On performance: the driver does per element what a counted loop used to do per container, and CBOR pays for it more than MessagePack because the value reader also has to be told whether to fetch a byte. Parsing 60,000 small objects and one array of a million integers is 3 to 4 % slower than the recursive reader, measured over five alternating runs. Against develop the same two inputs are about 44 % faster, because the entry point no longer copies the value it parsed; the earlier commit in this series is what pays for that. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Read MessagePack containers without recursing per nesting level
2026-09-09 09:47:58 +00:00 · 2026-09-09 10:21:22 +02:00 · 2026-09-09 10:21:21 +02:00 · 2026-09-09 10:21:21 +02:00 · 2026-09-09 10:21:20 +02:00 · 2026-09-09 10:21:20 +02:00
74 changed files with 4134 additions and 6284 deletions
@@ -108,7 +108,9 @@ The tests are located in [`tests/src/unit-*.cpp`](https://github.com/nlohmann/js
 are structured along the features of the library or the nature of the tests. Usually, it should be clear from the
 context which existing file needs to be extended, and only very few cases require creating new test files.
-When fixing a bug, edit `unit-regression2.cpp` and add a section referencing the fixed issue.
+When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
 `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
 MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
 #### Exceptions
@@ -11,7 +11,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -34,7 +34,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -9,7 +9,7 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
      with:
        egress-policy: audit
@@ -27,7 +27,7 @@ jobs:
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
      with:
        egress-policy: audit
@@ -19,7 +19,7 @@ jobs:
      pull-requests: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -17,7 +17,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -27,7 +27,7 @@ jobs:
      security-events: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -17,7 +17,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -26,7 +26,7 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -36,7 +36,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -32,7 +32,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -16,7 +16,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -35,7 +35,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -60,7 +60,7 @@ jobs:
        target: [ci_test_amalgamation, ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_simdutf]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -118,7 +118,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -369,7 +369,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -392,7 +392,7 @@ jobs:
        target: [ci_test_examples, ci_test_build_documentation]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
        with:
          egress-policy: audit
@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef
 ##########################################################################
 # configuration
@@ -41,6 +41,8 @@ all:
 	@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
 	@echo "pretty - beautify code with Artistic Style"
 	@echo "run_benchmarks - build and run benchmarks"
 	@echo "update_hedley - download Hedley and regenerate hedley.hpp / hedley_undef.hpp"
 	@echo "update_hedley_undef - rebuild hedley_undef.hpp from the JSON_HEDLEY_* #define names in hedley.hpp"
 ##########################################################################
@@ -241,11 +243,24 @@ update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
 	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp
-	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+	$(MAKE) update_hedley_undef
 	$(MAKE) amalgamate
 # Rebuild hedley_undef.hpp from every JSON_HEDLEY_* name that hedley.hpp
 # #defines. Hedley does not #undef all of its public macros internally (see
 # #5408), so grepping those #undef lines misses names such as
 # JSON_HEDLEY_PRAGMA. cmake/scripts/gen_hedley_undef_check.cmake is the
 # single source of truth for this extraction (tests/CMakeLists.txt uses the
 # same script, in MODE=checks, to generate the matching leak-check test), so
 # the vendored header, the generated #undef list, and the regression test
 # cannot drift apart.
 update_hedley_undef:
 	cmake -DHEDLEY_HPP=include/nlohmann/thirdparty/hedley/hedley.hpp \
 	      -DOUTPUT=include/nlohmann/thirdparty/hedley/hedley_undef.hpp \
 	      -DMODE=undef \
 	      -P cmake/scripts/gen_hedley_undef_check.cmake
 ##########################################################################
 # serve_header.py
 ##########################################################################
@@ -212,24 +212,6 @@ add_custom_target(ci_test_legacycomparison
    COMMENT "Compile and test with legacy discarded value comparison enabled"
 )
 ###############################################################################
 # Validate UTF-8 with simdutf.
 ###############################################################################
 add_custom_target(ci_test_simdutf
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON -DJSON_TestSimdutf=ON
    # simdutf needs C++17, so the library falls back to its scalar validator
    # below that: build the suite at C++11 to cover the fallback with the macro
    # defined, and at C++17 to run every test against simdutf itself
    "-DJSON_TestStandards=11\;17"
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_simdutf
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_simdutf
    COMMAND cd ${PROJECT_BINARY_DIR}/build_simdutf && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test with simdutf UTF-8 validation enabled"
 )
 ###############################################################################
 # Enable brace-init copy semantics.
 ###############################################################################
@@ -0,0 +1,112 @@
 # Shared extractor for the JSON_HEDLEY_* macro names defined in hedley.hpp.
 #
 # Every macro that hedley.hpp #defines must be #undef-ed again once json.hpp
 # has been fully processed (see include/nlohmann/detail/macro_unscope.hpp
 # and https://github.com/nlohmann/json/issues/5408). Deriving the macro list
 # straight from hedley.hpp here -- instead of hand-maintaining it in two
 # places -- means hedley_undef.hpp and the regression test that checks for
 # leaked macros can never drift apart, even after a future `make
 # update_hedley` pulls in new macros from upstream Hedley.
 #
 #   MODE=undef  (default): write hedley_undef.hpp (SPDX header, #pragma once,
 #               one #undef per macro name) -- used by `make update_hedley_undef`
 #   MODE=checks:            write one #ifdef/FAIL_CHECK/#endif per macro name,
 #               meant to be #include-d inside a TEST_CASE -- used by
 #               tests/CMakeLists.txt to (re)generate the include for
 #               tests/src/unit-no-macro-leak.cpp
 #
 # Required variables:
 #   HEDLEY_HPP  path to include/nlohmann/thirdparty/hedley/hedley.hpp
 #   OUTPUT      path of the file to (over)write
 # Optional:
 #   MODE        "undef" (default) or "checks"
 if(NOT DEFINED HEDLEY_HPP OR NOT DEFINED OUTPUT)
    message(FATAL_ERROR "HEDLEY_HPP and OUTPUT must be set")
 endif()
 if(NOT EXISTS "${HEDLEY_HPP}")
    message(FATAL_ERROR "Hedley header not found: ${HEDLEY_HPP}")
 endif()
 if(NOT DEFINED MODE)
    set(MODE undef)
 endif()
 if(NOT MODE STREQUAL "undef" AND NOT MODE STREQUAL "checks")
    message(FATAL_ERROR "MODE must be undef or checks, got: ${MODE}")
 endif()
 # Line-anchored, like `grep -oE "^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+"`.
 # Unanchored matching would also pick up JSON_HEDLEY_* mentions inside
 # comments or string literals elsewhere in the file, which must not turn
 # into #undef lines.
 file(STRINGS "${HEDLEY_HPP}" hedley_lines)
 set(macro_names)
 foreach(line IN LISTS hedley_lines)
    if("${line}" MATCHES "^[ \t]*#[ \t]*define[ \t]+(JSON_HEDLEY_[A-Za-z0-9_]+)")
        list(APPEND macro_names "${CMAKE_MATCH_1}")
    endif()
 endforeach()
 if(NOT macro_names)
    message(FATAL_ERROR "No JSON_HEDLEY_* macros found in ${HEDLEY_HPP}")
 endif()
 list(REMOVE_DUPLICATES macro_names)
 # Lexicographic, locale-independent (ASCII-only names) -- matches `LC_ALL=C sort`.
 list(SORT macro_names COMPARE STRING)
 list(LENGTH macro_names macro_count)
 set(generated "")
 if(MODE STREQUAL "undef")
    # Same banner `make update_hedley_undef` would stamp by hand, so the
    # recipe is self-contained and its output is byte-stable across reruns.
    # The embedded SPDX tags below are part of the *generated* file's
    # content, not a REUSE header for this .cmake script itself (which is
    # already covered by the blanket "Files: *" rule in .reuse/dep5) -- keep
    # them wrapped in REUSE-IgnoreStart/End so `reuse lint` does not try to
    # parse "MIT\n")" as this file's own SPDX-License-Identifier value.
    # REUSE-IgnoreStart
    string(APPEND generated "//     __ _____ _____ _____\n")
    string(APPEND generated "//  __|  |   __|     |   | |  JSON for Modern C++\n")
    string(APPEND generated "// |  |  |__   |  |  | | | |  version 3.12.0\n")
    string(APPEND generated "// |_____|_____|_____|_|___|  https://github.com/nlohmann/json\n")
    string(APPEND generated "//\n")
    string(APPEND generated "// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>\n")
    string(APPEND generated "// SPDX-License-Identifier: MIT\n")
    # REUSE-IgnoreEnd
    string(APPEND generated "\n")
    string(APPEND generated "#pragma once\n")
    string(APPEND generated "\n")
    foreach(name IN LISTS macro_names)
        string(APPEND generated "#undef ${name}\n")
    endforeach()
 else()
    string(APPEND generated "// This file is generated by cmake/scripts/gen_hedley_undef_check.cmake\n")
    string(APPEND generated "// from include/nlohmann/thirdparty/hedley/hedley.hpp. Do not edit it by\n")
    string(APPEND generated "// hand -- it is regenerated on every build. ${macro_count} macros checked.\n\n")
    foreach(name IN LISTS macro_names)
        string(APPEND generated "#ifdef ${name}\n")
        string(APPEND generated "    FAIL_CHECK(\"${name} leaked after including nlohmann/json.hpp\");\n")
        string(APPEND generated "#endif\n")
    endforeach()
 endif()
 get_filename_component(output_dir "${OUTPUT}" DIRECTORY)
 if(output_dir)
    file(MAKE_DIRECTORY "${output_dir}")
 endif()
 # Avoid rewriting the file (and busting downstream incremental rebuilds)
 # when the content has not actually changed.
 set(write_output TRUE)
 if(EXISTS "${OUTPUT}")
    file(READ "${OUTPUT}" existing_content)
    if(existing_content STREQUAL generated)
        set(write_output FALSE)
    endif()
 endif()
 if(write_output)
    file(WRITE "${OUTPUT}" "${generated}")
 endif()
@@ -34,6 +34,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
  location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
  unsuccessful.
@@ -75,3 +79,7 @@ is thrown. In any case, the original value is not changed: the patch is applied
 - Added in version 2.0.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
  target location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
  location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
@@ -30,6 +30,10 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
  location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
  location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
  unsuccessful.
@@ -72,3 +76,7 @@ function throws an exception.
 - Added in version 3.11.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
  target location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
  location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
@@ -24,7 +24,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
 ## Library version
@@ -1,71 +0,0 @@
 # JSON_USE_SIMDUTF
 ```cpp
 #define JSON_USE_SIMDUTF
 ```
 When defined, the parser validates the UTF-8 content of JSON strings that come from a **contiguous byte input**
 (`std::string`, `std::vector<char>`/`<std::uint8_t>`, string literals, `const char*` ranges, …) using the
 [simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. On text with many
 non-ASCII characters (e.g. CJK or emoji) this can validate several times faster.
 This is an **opt-in external dependency**. The library itself remains header-only and its behavior is unchanged: the
 same input is accepted or rejected either way, and every parse error is reported at the same position with the same
 message (simdutf is only used to fast-path *valid* runs; anything it flags falls back to the scalar path so the exact
 diagnostic is preserved). Streaming inputs (files, `std::istream`, wide strings, user-defined adapters) always use the
 scalar path.
 When `JSON_USE_SIMDUTF` is defined you must make the `simdutf.h` header available on the include path and link the
 simdutf library. When it is not defined, no simdutf header is included and there is no dependency.
 !!! note "Requires C++17"
    simdutf requires C++17 and its header rejects older standards with an `#!cpp #error`. The backend is therefore only
    compiled in from C++17 on. In C++11 and C++14 the macro has no effect and the scalar validator is used, which
    accepts and rejects exactly the same input -- only throughput differs. Setting the macro project-wide is therefore
    safe even when some translation units are built with an older standard.
 !!! warning "Define consistently"
    The macro selects between two definitions of the same inline validation function. It must therefore be defined
    identically for **every** translation unit that includes the library; mixing translation units that define it with
    ones that do not is an ODR violation. Prefer setting it as a compile definition on the target rather than with
    `#!cpp #define` in individual source files.
 ## Default definition
 By default, `#!cpp JSON_USE_SIMDUTF` is not defined and the portable C++11 scalar validator is used.
 ```cpp
 #undef JSON_USE_SIMDUTF
 ```
 ## Examples
 ??? example
    The code below enables the simdutf backend for UTF-8 validation.
    ```cpp
    #define JSON_USE_SIMDUTF 1
    #include <nlohmann/json.hpp>
    ...
    ```
    The project must also link against simdutf, e.g. with CMake:
    ```cmake
    target_compile_definitions(your_target PRIVATE JSON_USE_SIMDUTF)
    target_link_libraries(your_target PRIVATE simdutf::simdutf)
    ```
 !!! hint "Testing this configuration"
    The unit tests can be built against the simdutf backend with the CMake option `JSON_TestSimdutf` (`OFF` by
    default), which fetches simdutf and defines `JSON_USE_SIMDUTF` for every test target. The `ci_test_simdutf` target
    runs the whole test suite in that configuration.
 ## Version history
 - Added in version 3.13.0.
@@ -4,8 +4,8 @@
 Hello, world!
 1 2 3 4 5 
 string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
 string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
@@ -4,8 +4,8 @@
 Hello, world!
 1 2 3 4 5 
 string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
 string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
@@ -4,9 +4,9 @@
 Hello, world!
 1 2 3 4 5 
 string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
 string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
 [json.exception.type_error.302] type must be boolean, but is string
@@ -125,6 +125,7 @@ The library uses the following mapping from JSON values types to BJData types ac
    - `"_ArrayType_"` is one of `uint8`, `int8`, `uint16`, `int16`, `uint32`, `int32`, `uint64`, `int64`, `single`,
      `double`, `char`, or `byte`,
    - `"_ArraySize_"` is an array, since the dimensions are written as the ND-array header's length,
    - every entry of `"_ArraySize_"` is a non-negative integer, and their product is representable as a `std::size_t`,
    - `"_ArrayData_"` holds exactly that many elements, and
    - every element of `"_ArrayData_"` is a number of the kind named by `"_ArrayType_"` (a floating-point number for
@@ -69,6 +69,13 @@ The library uses the following mapping from JSON values types to UBJSON types ac
    Note that `use_size = true` alone may result in larger representations - the benefit of this parameter is that the
    receiving side is immediately informed on the number of elements of the container.
    An array whose type marker is `Z` (null), `T` (true) or `F` (false) stores no payload at all, because the marker
    already is the value. Its declared count is therefore the only thing that decides how much memory the receiving side
    allocates, and a handful of bytes can describe billions of elements. `from_ubjson` rejects such an array with
    [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408) when the count exceeds 1,048,576
    (`1 << 20`), and `to_ubjson` writes longer arrays of these types without the annotation, so any value it produces
    can be read back.
 !!! info "Binary values"
    If the JSON data contains the binary type, the value stored is a list of integers, as suggested by the UBJSON
@@ -137,14 +137,6 @@ behavior is deprecated and switched off (`0`) by default.
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
 ## `JSON_USE_SIMDUTF`
 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the
 [simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. This is an opt-in
 external dependency and is not defined by default.
 See [full documentation of `JSON_USE_SIMDUTF`](../api/macros/json_use_simdutf.md).
 ## `NLOHMANN_DEFINE_TYPE_*(...)`, `NLOHMANN_DEFINE_DERIVED_TYPE_*(...)`
 The library defines 12 macros to simplify the serialization/deserialization of types. See the page on
@@ -8,41 +8,72 @@ the result of an internet search. If you know further customers of the library,
 ## Space Exploration
 - [**Peregrine Lunar Lander Flight 01**](https://en.wikipedia.org/wiki/Peregrine_Mission_One) - The library was used for payload management in the **Peregrine Moon Lander**, developed by **Astrobotic Technology** and launched as part of NASA's **Commercial Lunar Payload Services (CLPS)** program. After six days in orbit, the spacecraft was intentionally redirected into Earth's atmosphere, where it burned up over the Pacific Ocean on **January 18, 2024**.
 - [**NASA Unsteady Pressure-Sensitive Paint Processing**](https://github.com/nasa/upsp-processing), NASA software for processing high-speed video recordings of wind tunnel tests on launch vehicle and aircraft models
 - [**Terma TEMU**](https://temu.terma.com/docs/public/temu-release-notes/latest/copying/json-for-modern-cpp.html), an emulator of spacecraft on-board computers used to develop and validate flight software for European space missions
 ## Automotive
 - [**Alexa Auto SDK**](https://github.com/alexa/alexa-auto-sdk), a software development kit enabling the integration of Alexa into automotive systems
 - [**Apollo**](https://github.com/ApolloAuto/apollo), a framework for building autonomous driving systems
 - [**Automotive Grade Linux (AGL)**](https://download.automotivelinux.org/AGL/release/jellyfish/latest/qemux86-64/deploy/licenses/nlohmann-json/), a collaborative open-source platform for automotive software development
 - [**Autoware**](https://github.com/autowarefoundation/autoware_universe), an open-source software stack for autonomous driving built on ROS 2
 - [**Eclipse S-CORE**](https://github.com/eclipse-score/nlohmann_json), an open-source software platform for the software-defined vehicle backed by major automotive manufacturers and suppliers
 - [**Genesis Motor** (infotainment)](http://webmanual.genesis.com/ccIC/AVNT/JW/KOR/English/reference010.html), a luxury automotive brand
 - [**Hyundai** (infotainment)](https://www.hyundai.com/wsvc/ww/download.file.do?id=/content/hyundai/ww/data/opensource/data/GN7-2022/licenseCode/info), a global automotive brand
 - [**Kia** (infotainment)](http://webmanual.kia.com/PREM_GEN6/AVNT/RJPE/KOR/Korean/reference010.html), a global automotive brand
 - [**Mercedes-Benz Operating System (MB.OS)**](https://group.mercedes-benz.com/careers/about-us/mercedes-benz-operating-system/), a core component of the vehicle software ecosystem from Mercedes-Benz
 - [**NVIDIA DRIVE OS**](https://developer.nvidia.com/docs/drive/drive-os/6.0.5/public/driveworks-nvcgf/dwx_open_source_attribution.html), the operating system and DriveWorks SDK powering NVIDIA's platform for autonomous vehicles
 - [**Rivian** (infotainment)](https://assets.ctfassets.net/2md5qhoeajym/3cwyo4eoufk4yingUwusFt/ded2c47da620fdfc99c88c7156d2c1d8/In-Vehicle_OSS_Attribution_2024__11-24_.pdf), an electric vehicle manufacturer
 - [**Suzuki** (infotainment)](https://www.globalsuzuki.com/motorcycle/ipc/oss/oss_48KA_00.pdf), a global automotive and motorcycle manufacturer
 ## Gaming and Entertainment
 - [**Anno 117: Pax Romana**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a city-building strategy game set in the Roman Empire
 - [**Assassin's Creed: Mirage**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a stealth-action game set in the Middle East, focusing on the journey of a young assassin with classic parkour and stealth mechanics
 - [**Battlefield 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a military first-person shooter known for its large-scale multiplayer battles
 - [**Battlefield: REDSEC**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play battle royale experience set in the Battlefield universe
 - [**BioMenace: Remastered**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a remaster of the classic side-scrolling platform shooter
 - [**Chasm: The Rift**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a first-person shooter blending horror and adventure, where players navigate dark realms and battle monsters
 - [**College Football 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring gameplay that mimics real-life college teams and competitions
 - [**College Football 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring licensed teams and stadiums
 - [**College Football 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the college football simulation series
 - [**Concepts**](https://concepts.app/en/licenses), a digital sketching app designed for creative professionals, offering flexible drawing tools for illustration, design, and brainstorming
 - [**Depthkit**](https://www.depthkit.tv/third-party-licenses), a tool for creating and capturing volumetric video, enabling immersive 3D experiences and interactive content
 - [**Dune: Awakening**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world survival MMO set on the desert planet Arrakis
 - [**EA Sports FC 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an association football simulation with club, career, and online modes
 - [**EA Sports FC 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the association football simulation series
 - [**EA Sports UFC 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a mixed martial arts fighting simulation
 - [**FiveM**](https://github.com/citizenfx/fivem), a modification framework for Grand Theft Auto V that powers custom multiplayer servers
 - [**FLUX:: Immersive**](https://doc.flux.audio/syrah/Credits.html), a suite of professional audio processing and immersive mixing plugins used in music and post-production
 - [**IMG.LY**](https://img.ly/acknowledgements), a platform offering creative tools and SDKs for integrating advanced image and video editing in applications
 - [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications
 - [**Kodi**](https://github.com/xbmc/xbmc/blob/master/xbmc/utils/JSONVariantWriter.cpp), a home theater and media center application
 - [**LOOT**](https://loot.readthedocs.io/_/downloads/en/0.13.0/pdf/), a tool for optimizing the load order of game plugins, commonly used in The Elder Scrolls and Fallout series
 - [**LunaTranslator**](https://github.com/HIllya51/LunaTranslator/blob/main/src/NativeImpl/LunaSubprocess/aspatch.cpp), a real-time translation tool for visual novels
 - [**MaaAssistantArknights**](https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/dev-v2/src/MaaCore/Vision/Roguelike/BlackFlow/BlackFlowMapAnalyzer.cpp), an automation assistant for the mobile game Arknights
 - [**Madden NFL 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a sports simulation game capturing the excitement of American football with realistic gameplay and team management features
 - [**Madden NFL 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an American football simulation with franchise and team management modes
 - [**Madden NFL 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the American football simulation series
 - [**Marne**](https://marne.io/licenses), an unofficial private server platform for hosting custom Battlefield 1 game experiences
 - [**Minecraft**](https://www.minecraft.net/zh-hant/attribution), a popular sandbox video game
 - [**Mumble**](https://github.com/mumble-voip/mumble), a low-latency, open-source voice chat application widely used by gaming communities
 - [**NHL 22**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a hockey simulation game offering realistic gameplay, team management, and various modes to enhance the hockey experience
 - [**OBS Studio**](https://github.com/obsproject/obs-studio), a free and open-source suite for video recording and live streaming
 - [**OpenRCT2**](https://github.com/OpenRCT2/OpenRCT2/blob/develop/src/openrct2/core/JsonFwd.hpp), an open source re-implementation of RollerCoaster Tycoon 2
 - [**Pixelpart**](https://pixelpart.net/documentation/book/third-party.html), a 2D animation and video compositing software that allows users to create animated graphics and visual effects with a focus on simplicity and ease of use
 - [**Razer Cortex**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a gaming performance optimizer and system booster designed to enhance the gaming experience
 - [**Red Dead Redemption II**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world action-adventure game following an outlaw's story in the late 1800s, emphasizing deep storytelling and immersive gameplay
 - [**RetroArch**](https://github.com/libretro/RetroArch), a frontend for emulators, game engines, and media players built on the libretro API
 - [**shadPS4**](https://github.com/shadps4-emu/shadPS4/blob/main/src/core/user_manager.h), a PlayStation 4 emulator for Windows, Linux and macOS
 - [**skate.**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play skateboarding game set in an open world
 - [**Snapchat**](https://www.snap.com/terms/license-android), a multimedia messaging and augmented reality app for communication and entertainment
 - [**Steel Century Groove**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an action game released in 2026
 - [**Sunshine**](https://github.com/LizardByte/Sunshine/blob/master/src/confighttp.h), a self-hosted game streaming host compatible with Moonlight clients
 - [**Tactics Ogre: Reborn**](https://www.square-enix-games.com/en_US/documents/tactics-ogre-reborn-pc-installer-software-and-associated-plug-ins-disclosure), a tactical role-playing game featuring strategic battles and deep storytelling elements
 - [**Throne and Liberty**](https://www.amazon.com/gp/help/customer/display.html?nodeId=T7fLNw5oAevCMtJFPj&pop-up=1), an MMORPG that offers an expansive fantasy world with dynamic gameplay and immersive storytelling
 - [**Unity Vivox**](https://docs.unity3d.com/Packages/com.unity.services.vivox@15.1/license/Third%20Party%20Notices.html), a communication service that enables voice and text chat functionality in multiplayer games developed with Unity
 - [**xemu**](https://github.com/xemu-project/xemu), an emulator of the original Xbox console
 - [**Zool: Redimensioned**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a modern reimagining of the classic platformer featuring fast-paced gameplay and vibrant environments
 - [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications
 ## Consumer Electronics
@@ -50,109 +81,195 @@ the result of an internet search. If you know further customers of the library,
 - [**Canon CanoScan LIDE**](https://carolburo.com/wp-content/uploads/2024/06/LiDE400_OnlineManual_Win_FR_V02.pdf), a series of flatbed scanners offering high-resolution image scanning for home and office use
 - [**Canon PIXMA Printers**](https://www.mediaexpert.pl/products/files/73/7338196/Instrukcja-obslugi-CANON-Pixma-TS7450i.pdf), a line of all-in-one inkjet printers known for high-quality printing and wireless connectivity
 - [**Cisco Webex Desk Camera**](https://www.cisco.com/c/dam/en_us/about/doing_business/open_source/docs/CiscoWebexDeskCamera-23-1622100417.pdf), a video camera designed for professional-quality video conferencing and remote collaboration
 - [**DJI Edge SDK**](https://github.com/dji-sdk/Edge-SDK-V2-Demo), the reference applications for DJI's Edge SDK, used to build edge computing services on DJI drone docks
 - [**Elgato Stream Deck**](https://github.com/elgatosf/streamdeck-obs-plugin2), a family of programmable control surfaces for content creators and their plugin ecosystem
 - [**Instagrid**](https://instagrid.co/intellectual-property/foss), a manufacturer of portable, high-performance battery systems for professional mobile power supply
 - [**iRobot**](https://iot-content.irobot.com/iw/sfsites/c/cms/delivery/media/MCKRLTPDJSSJBNJKDA5SG5UVVIIQ), a manufacturer of autonomous home robots including the Roomba vacuum cleaner range
 - [**Logitech Logi Bolt**](https://opensource.logitech.com/wiki/Logi_BoltApp/), the management application for Logitech's secure wireless connectivity technology
 - [**Novitus**](https://novitus.pl/licencjepensource), a manufacturer of fiscal cash registers and point-of-sale devices
 - [**Philips Hue Personal Wireless Lighting**](http://2ak5ape.257.cz/), a smart lighting system for customizable and wireless home illumination
 - [**Ray-Ban Meta Smart glasses**](https://www.meta.com/de/en/legal/smart-glasses/third-party-notices-android/03/), a pair of smart glasses designed for capturing photos and videos with integrated connectivity and social features
 - [**Razer Synapse**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a unified configuration software enabling hardware customization for Razer devices
 - [**Sharp Professional Displays**](https://jp.sharp/restricted/business/lcd-display/cms/images/source_pnla862/PN-LA652_752_862_LicenseInformation.pdf), a range of large-format interactive displays for business and education
 - [**Siemens SINEMA Remote Connect**](https://cache.industry.siemens.com/dl/files/790/109793790/att_1054961/v2/OSS_SINEMA-RC_86.pdf), a remote connectivity solution for monitoring and managing industrial networks and devices securely
 - [**Skydio**](https://pages.skydio.com/rs/784-TUF-591/images/Open%20Source%20Software%20Notice%20v0.2.html), a manufacturer of autonomous drones for inspection, public safety, and defense applications
 - [**Sony PlayStation 4**](https://doc.dl.playstation.net/doc/ps4-oss/index.html), a gaming console developed by Sony that offers a wide range of games and multimedia entertainment features
 - [**Sony Spatial Reality Display**](https://www.sony.co.jp/en/Products/Developer-Spatial-Reality-display/download/dcc-tools/blender-plugin/SpatiaRealityDisplayPluginforPreviewBL_Manual.pdf), a glasses-free stereoscopic 3D display and its plugins for Blender, 3ds Max, and ZBrush
 - [**Sony Virtual Webcam Driver for Remote Camera**](https://helpguide.sony.net/rc/vwd/v1/zh-cn/print.pdf), a software driver that enables the use of Sony cameras as virtual webcams for video conferencing and streaming
 - [**Yamaha Clavinova**](https://usa.yamaha.com/files/download/other_assets/1/2298171/CLP-800_oss_license.pdf), a series of digital pianos combining acoustic piano feel with digital sound technology
-## Operating Systems
+## Operating Systems and Platforms
 - [**Apple iOS and macOS**](https://www.apple.com/macos), a family of operating systems developed by Apple, including iOS for mobile devices and macOS for desktop computers
 - [**Chromium**](https://chromium.googlesource.com/chromium/src/+/main/third_party/nlohmann_json/), the open-source browser project that Google Chrome, Microsoft Edge, and many other browsers are built on, where the library is used as data container for on-device model execution
 - [**Google Fuchsia**](https://fuchsia.googlesource.com/third_party/json/), an open-source operating system developed by Google, designed to be secure, updatable, and adaptable across various devices
 - [**LG webOS**](https://github.com/webosose/com.webos.service.camera), a Linux-based operating system used in LG smart TVs, signage, and embedded devices
 - [**Microsoft Azure Linux**](https://github.com/microsoft/azurelinux), a Linux distribution developed by Microsoft for Azure infrastructure and edge workloads
 - [**OpenHarmony**](https://github.com/openharmony/third_party_json), an open-source operating system for smart devices and the foundation of HarmonyOS
 - [**SerenityOS**](https://github.com/SerenityOS/serenity), an open-source operating system that aims to provide a simple and beautiful user experience with a focus on simplicity and elegance
 - [**Windows Subsystem for Linux**](https://github.com/microsoft/WSL), a compatibility layer that runs Linux environments natively on Windows
 - [**Yocto**](http://ftp.emacinc.com/openembedded-sw/kirkstone-icop-5.15-kirkstone-6.0/archive-2024-10/pn8m-090t-ppc/licenses/nlohmann-json/), a Linux-based build system for creating custom operating systems and software distributions, tailored for embedded devices and IoT applications
 ## Development Tools and IDEs
 - [**Accentize SpectralBalance**](https://www.accentize.com/products/SpectralBalanceManual.pdf), an adaptive speech analysis tool designed to enhance audio quality by optimizing frequency balance in recordings
 - [**Airbus Ghidralligator**](https://www.cyber.airbus.com/en/newsroom/stories/2025-06-ghidralligator), a Ghidra-based emulator from Airbus CyberSecurity used to fuzz and analyse embedded firmware
 - [**Apache brpc**](https://github.com/apache/brpc/blob/master/src/butil/iobuf.h), an industrial-grade remote procedure call framework for C++
 - [**Arm Compiler for Linux**](https://documentation-service.arm.com/static/66558e9d876c8d213b7843e4), a software development toolchain for compiling and optimizing applications on Arm-based Linux systems
 - [**BBEdit**](https://s3.amazonaws.com/BBSW-download/BBEdit_15.1.2_User_Manual.pdf), a professional text and code editor for macOS
 - [**CoderPad**](https://coderpad.io), a collaborative coding platform that enables real-time code interviews and assessments for developers; the library is included in every CoderPad instance and can be accessed with a simple `#include "json.hpp"`
 - [**Codon**](https://github.com/exaloop/codon/blob/develop/jupyter/jupyter.h), an ahead-of-time compiler for a Python-like language
 - [**Compiler Explorer**](https://godbolt.org), a web-based tool that allows users to write, compile, and visualize the assembly output of code in various programming languages; the library is readily available and accessible with the directive `#include <nlohmann/json.hpp>`.
- [**GitHub CodeQL**](https://github.com/github/codeql), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
+- [**Flutter**](https://github.com/flutter/flutter/blob/master/engine/src/flutter/impeller/compiler/reflector.cc), a UI toolkit for building natively compiled applications for mobile, web, and desktop from a single codebase
 - [**Fraunhofer VVenC**](https://github.com/fraunhoferhhi/vvenc), a fast and efficient encoder for the Versatile Video Coding (H.266/VVC) standard
 - [**GitHub CodeQL**](https://github.com/github/codeql/blob/main/shared/cpp/Diagnostics.h), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
 - [**GoPro ngfx**](https://github.com/gopro/ngfx), a low-level graphics abstraction and profiling framework developed by GoPro
 - [**gRPC**](https://github.com/grpc/grpc/blob/master/tools/artifact_gen/utils.h), a high-performance universal remote procedure call framework
 - [**Hex-Rays**](https://docs.hex-rays.com/user-guide/user-interface/licenses), a reverse engineering toolset for analyzing and decompiling binaries, primarily used for security research and vulnerability analysis
 - [**ImHex**](https://github.com/WerWolv/ImHex), a hex editor designed for reverse engineering, providing advanced features for data analysis and manipulation
 - [**Intel GITS**](https://github.com/intel/gits), a tool for capturing and replaying graphics API calls for debugging and performance analysis
 - [**Intel GPA Framework**](https://intel.github.io/gpasdk-doc/src/licenses.html), a suite of cross-platform tools for capturing, analyzing, and optimizing graphics applications across different APIs
 - [**Intopix**](https://www.intopix.com/software-licensing), a provider of advanced image processing and compression solutions used in software development and AV workflows
 - [**Java SE**](https://www.oracle.com/a/tech/docs/jdk8-lium.pdf), the core Java platform that provides the libraries and runtime needed to build and run general-purpose Java applications
 - [**MKVToolNix**](https://mkvtoolnix.download/doc/README.md), a set of tools for creating, editing, and inspecting MKV (Matroska) multimedia container files
 - [**Meta Yoga**](https://github.com/facebook/yoga), a layout engine that facilitates flexible and efficient user interface design across multiple platforms
- [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
+- [**MKVToolNix**](https://mkvtoolnix.download/doc/README.md), a set of tools for creating, editing, and inspecting MKV (Matroska) multimedia container files
 - [**MRTech IFF SDK**](https://mr-technologies.com/pub/iff-sdk-manual-2-0-1/iff-sdk-manual-2-0-1.pdf), an image processing SDK for machine vision applications with GPU-accelerated pipelines
 - [**Nix**](https://github.com/NixOS/nix/blob/master/src/nix/build.cc), a purely functional package manager
 - [**Notepad++**](https://github.com/notepad-plus-plus/notepad-plus-plus), a free source code editor that supports various programming languages
 - [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
 - [**openFrameworks**](https://github.com/openframeworks/openFrameworks/blob/master/libs/openFrameworks/utils/ofJson.h), a community-developed C++ toolkit for creative coding
 - [**OpenRGB**](https://gitlab.com/CalcProgrammer1/OpenRGB), an open source RGB lighting control that doesn't depend on manufacturer software
 - [**OpenTelemetry C++**](https://github.com/open-telemetry/opentelemetry-cpp), a library for collecting and exporting observability data in C++, enabling developers to implement distributed tracing and metrics in their application
 - [**Oracle GraalVM**](https://docs.oracle.com/en/graalvm/jdk/21/docs/licensing-information/), a high-performance JDK distribution with ahead-of-time compilation and polyglot runtime support
 - [**Philips amp-cucumber-cpp-runner**](https://github.com/philips-software/amp-cucumber-cpp-runner), a behaviour-driven development test runner for embedded C++ software developed at Philips
 - [**Qt Creator**](https://doc.qt.io/qtcreator/qtcreator-attribution-json-nlohmann.html), an IDE for developing applications using the Qt application framework
 - [**Qt for MCUs**](https://doc.qt.io/QtForMCUs/quickultralite-attribution-nlohmann-json.html), a graphics framework for building fluid user interfaces on microcontrollers
 - [**React Native**](https://github.com/react/react-native/blob/main/packages/react-native/ReactCxxPlatform/react/devsupport/PackagerConnection.cpp), a framework for building native mobile applications using React
 - [**Scanbot SDK**](https://docs.scanbot.io/barcode-scanner-sdk/web/third-party-libraries/), a software development kit (SDK) that provides tools for integrating advanced document scanning and barcode scanning capabilities into applications
 - [**STMicroelectronics TouchGFX**](https://www.st.com/resource/en/additional_license_terms/additional-license-terms-x-cube-touchgfx.html), a graphical user interface framework shipped with STM32 microcontrollers for building embedded HMIs
 - [**swagger-codegen**](https://github.com/swagger-api/swagger-codegen/blob/master/samples/server/petstore/pistache-server/model/Pet.h), a template-driven engine that generates API clients and server stubs from an OpenAPI specification
 - [**Swoole**](https://github.com/swoole/swoole-src/blob/master/ext-src/swoole_admin_server.cc), a coroutine-based concurrency engine for PHP
 - [**Tracy Profiler**](https://github.com/wolfpld/tracy/blob/master/profiler/src/profiler/TracyLlm.hpp), a real-time frame profiler for games and other applications
 - [**WasmEdge**](https://github.com/WasmEdge/WasmEdge/blob/master/plugins/wasi_nn/GGML/tts/tts_core.cpp), a lightweight WebAssembly runtime for edge and cloud workloads
 - [**x64dbg**](https://github.com/x64dbg/x64dbg/blob/development/src/cross/remote_table/TableRpcData.h), an open source user mode debugger for Windows, aimed at reverse engineering and malware analysis
 ## Machine Learning and AI
 - [**Alibaba MNN**](https://github.com/alibaba/MNN), a lightweight deep learning inference engine for mobile and embedded devices
 - [**AMD Gaia**](https://github.com/amd/gaia), an open-source framework for running generative AI applications locally on AMD hardware
 - [**AMD Vitis AI (VAIP)**](https://github.com/amd/vaip), the execution provider stack that runs AI models on AMD Ryzen AI and adaptive computing devices
 - [**Apple Core ML Tools**](https://github.com/apple/coremltools), a set of tools for converting and configuring machine learning models for deployment in Apple's Core ML framework
 - [**Avular Mobile Robotics**](https://www.avular.com/licenses/nlohmann-json-3.9.1.txt), a platform for developing and deploying mobile robotics solutions
 - [**FunASR**](https://github.com/modelscope/FunASR/blob/main/runtime/http/bin/asr_sessions.h), a speech recognition toolkit for training and deploying end-to-end models
 - [**Google gemma.cpp**](https://github.com/google/gemma.cpp), a lightweight C++ inference engine designed for running AI models from the Gemma family
 - [**Google Magenta The Infinite Crate**](https://github.com/magenta/the-infinite-crate), an open-source generative AI plugin for digital audio workstations from Google's Magenta research team
 - [**GPT4All**](https://github.com/nomic-ai/gpt4all/blob/main/gpt4all-chat/src/tool.h), a desktop application for running local large language models on consumer hardware
 - [**Huawei MindSpore**](https://github.com/mindspore-ai/mindspore/blob/master/Third_Party_Open_Source_Software_Notice), a deep learning framework for training and inference across device, edge, and cloud
 - [**KTransformers**](https://github.com/kvcache-ai/ktransformers/blob/main/archive/csrc/balance_serve/sched/model_config.h), a framework for heterogeneous large language model inference
 - [**llama.cpp**](https://github.com/ggerganov/llama.cpp), a C++ library designed for efficient inference of large language models (LLMs), enabling streamlined integration into applications
 - [**LocalAI**](https://github.com/mudler/LocalAI/blob/master/backend/cpp/ds4/dsml_renderer.cpp), a self-hosted inference engine that exposes local models through an OpenAI-compatible API
 - [**MLX**](https://github.com/ml-explore/mlx), an array framework for machine learning on Apple Silicon
 - [**Mozilla llamafile**](https://github.com/Mozilla-Ocho/llamafile), a tool designed for distributing and executing large language models (LLMs) efficiently using a single file format
 - [**NVIDIA ACE**](https://docs.nvidia.com/ace/latest/index.html), a suite of real-time AI solutions designed for the development of interactive avatars and digital human applications, enabling scalable and sophisticated user interactions
 - [**NVIDIA Instant NGP**](https://github.com/NVlabs/instant-ngp/blob/master/src/nerf_loader.cu), an implementation of instant neural graphics primitives for rapid scene reconstruction
 - [**NVIDIA TensorRT**](https://github.com/NVIDIA/TensorRT), an SDK for high-performance deep learning inference, including its TensorRT-LLM extension for large language models
 - [**NVIDIA TensorRT-LLM**](https://github.com/NVIDIA/TensorRT-LLM/blob/main/cpp/tensorrt_llm/common/safetensors.cpp), a toolkit for optimizing and serving large language model inference on GPUs
 - [**ONNX Runtime**](https://github.com/microsoft/onnxruntime), a cross-platform inference and training accelerator for machine learning models
 - [**OpenVINO**](https://github.com/openvinotoolkit/openvino), Intel's toolkit for optimizing and deploying deep learning inference across CPUs, GPUs, and NPUs
 - [**PaddleOCR**](https://github.com/PaddlePaddle/PaddleOCR/blob/main/deploy/cpp_infer/src/modules/text_detection/result.cc), an optical character recognition toolkit that turns documents and images into structured data
 - [**PaddlePaddle**](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/ap/src/axpr/anf_expr.cc), a deep learning framework for distributed training and inference
 - [**Peer**](https://support.peer.inc/hc/en-us/articles/17261335054235-Licenses), a platform offering personalized AI assistants for interactive learning and creative collaboration
 - [**PyTorch**](https://github.com/pytorch/pytorch), a machine learning framework for building and training neural networks, widely used in research and production
 - [**Qualcomm AI Engine Direct**](https://github.com/qualcomm/qai-appbuilder), a toolchain for building and running generative AI applications on Snapdragon devices
 - [**sherpa-onnx**](https://github.com/k2-fsa/sherpa-onnx/blob/master/sherpa-onnx/csrc/sentence-piece-tokenizer.cc), a speech toolkit for on-device recognition, synthesis and speaker diarization
 - [**stable-diffusion.cpp**](https://github.com/leejet/stable-diffusion.cpp), a C++ implementation of the Stable Diffusion image generation model
 - [**TanvasTouch**](https://tanvas.co/tanvastouch-sdk-third-party-acknowledgments), a software development kit (SDK) that enables developers to create tactile experiences on touchscreens, allowing users to feel textures and physical sensations in a digital environment
 - [**TensorFlow**](https://github.com/tensorflow/tensorflow), a machine learning framework that facilitates the development and training of models, supporting data serialization and efficient data exchange between components
 - [**whisper.cpp**](https://github.com/ggml-org/whisper.cpp), a C++ implementation of OpenAI's Whisper automatic speech recognition model
 ## Scientific Research and Analysis
 - [**BLACK**](https://www.black-sat.org/en/stable/installation/linux.html), a bounded linear temporal logic (LTL) satisfiability checker
 - [**CERN ALICE O2**](https://github.com/AliceO2Group/AliceO2), the online-offline computing framework of the ALICE heavy-ion experiment at the Large Hadron Collider
 - [**CERN Atlas Athena**](https://gitlab.cern.ch/atlas/athena/-/blob/main/Control/PerformanceMonitoring/PerfMonComps/src/PerfMonMTSvc.h), a software framework used in the ATLAS experiment at the Large Hadron Collider (LHC) for performance monitoring
 - [**CERN CMSSW**](https://github.com/cms-sw/cmssw), the offline software framework of the CMS experiment at the Large Hadron Collider
 - [**CERN Gaudi**](https://gitlab.cern.ch/gaudi/Gaudi), the event-processing framework used by the LHCb and ATLAS experiments at the Large Hadron Collider
 - [**ICU**](https://github.com/unicode-org/icu), the International Components for Unicode, a mature library for software globalization and multilingual support
 - [**KAMERA**](https://github.com/Kitware/kamera), a platform for synchronized data collection and real-time deep learning to map marine species like polar bears and seals, aiding Arctic ecosystem research
 - [**KiCad**](https://gitlab.com/kicad/code/kicad/-/tree/master/thirdparty/nlohmann_json), a free and open-source software suite for electronic design automation
 - [**LLNL ROSE**](https://github.com/llnl/rose), a compiler infrastructure from Lawrence Livermore National Laboratory for building source-to-source program analysis and transformation tools
 - [**Maple**](https://www.maplesoft.com/support/help/Maple/view.aspx?path=copyright), a symbolic and numeric computing environment for advanced mathematical modeling and analysis
 - [**MeVisLab**](https://mevislabdownloads.mevis.de/docs/current/MeVis/ThirdParty/Documentation/Publish/ThirdPartyReference/index.html), a software framework for medical image processing and visualization.
 - [**MITK**](https://github.com/MITK/MITK), the Medical Imaging Interaction Toolkit, a framework for developing interactive medical image processing software
 - [**OpenPMD API**](https://openpmd-api.readthedocs.io/en/0.8.0-alpha/backends/json.html), a versatile programming interface for accessing and managing scientific data, designed to facilitate the efficient storage, retrieval, and sharing of simulation data across various applications and platforms
 - [**ORNL DataFed**](https://github.com/ORNL/DataFed), a federated scientific data management system developed at Oak Ridge National Laboratory
 - [**ParaView**](https://github.com/Kitware/ParaView), an open-source tool for large-scale data visualization and analysis across various scientific domains
 - [**QGIS**](https://gitlab.b-data.ch/qgis/qgis/-/blob/backport-57658-to-release-3_34/external/nlohmann/json.hpp), a free and open-source geographic information system (GIS) application that allows users to create, edit, visualize, and analyze geospatial data across a variety of formats
- [**VTK**](https://github.com/Kitware/VTK), a software library for 3D computer graphics, image processing, and visualization
+- [**Sandia InterSpec**](https://github.com/sandialabs/InterSpec), spectral radiation analysis software from Sandia National Laboratories for identifying radioactive isotopes
 - [**VolView**](https://github.com/Kitware/VolView), a lightweight application for interactive visualization and analysis of 3D medical imaging data.
 - [**VTK**](https://github.com/Kitware/VTK), a software library for 3D computer graphics, image processing, and visualization
 ## Business and Productivity Software
 - [**ArcGIS PRO**](https://www.esri.com/content/dam/esrisites/en-us/media/legal/open-source-acknowledgements/arcgis-pro-2-8-attribution-report.html), a desktop geographic information system (GIS) application developed by Esri for mapping and spatial analysis
 - [**Autodesk Desktop**](https://damassets.autodesk.net/content/dam/autodesk/www/Company/legal-notices-trademarks/autodesk-desktop-platform-components/internal-autodesk-components-web-page-2023.pdf), a software platform developed by Autodesk for creating and managing desktop applications and services
 - [**Check Point**](https://www.checkpoint.com/about-us/copyright-and-trademarks/), a cybersecurity company specializing in threat prevention and network security solutions, offering a range of products designed to protect enterprises from cyber threats and ensure data integrity
 - [**EasyEffects**](https://github.com/wwmm/easyeffects/blob/master/src/presets_manager.hpp), an audio effects processor for PipeWire offering limiting, compression and equalization
 - [**espanso**](https://github.com/espanso/espanso/blob/dev/espanso-ui/src/win32/native.cpp), a cross-platform text expander
 - [**Karabiner-Elements**](https://github.com/pqrs-org/Karabiner-Elements/blob/main/src/share/app_icon.hpp), a keyboard customizer for macOS
 - [**MacType**](https://github.com/snowie2000/mactype/blob/directwrite/settings.h), a font rendering engine for Windows
 - [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
 - [**Microsoft Office for Mac**](https://officecdnmac.microsoft.com/pr/legal/mac/OfficeforMacAttributions.html), a suite of productivity applications developed by Microsoft for macOS, including tools for word processing, spreadsheets, and presentations
 - [**Microsoft Teams**](https://www.microsoft.com/microsoft-teams/), a team collaboration application offering workspace chat and video conferencing, file storage, and integration of proprietary and third-party applications and services
 - [**MuseScore**](https://github.com/musescore/MuseScore), a free and open-source music notation and composition application
 - [**NanaZip**](https://github.com/M2Team/NanaZip/blob/main/NanaZip.Codecs/NanaZip.Codecs.Archive.ElectronAsar.cpp), a 7-Zip derivative built for modern Windows
 - [**Nexthink Infinity**](https://docs.nexthink.com/legal/services-terms/experience-open-source-software-licenses/infinity-2022.8-software-licenses), a digital employee experience management platform for monitoring and improving IT performance
 - [**Sophos Connect Client**](https://docs.sophos.com/nsg/licenses/SophosConnect/SophosConnectAttribution.html), a secure VPN client from Sophos that allows remote users to connect to their corporate network, ensuring secure access to resources and data
 - [**Stonebranch**](https://stonebranchdocs.atlassian.net/wiki/spaces/UA77/pages/799545647/Licenses+for+Third-Party+Libraries), a cloud-based cybersecurity solution that integrates backup, disaster recovery, and cybersecurity features to protect data and ensure business continuity for organizations
 - [**Tablecruncher**](https://tablecruncher.com/), a data analysis tool that allows users to import, analyze, and visualize spreadsheet data, offering interactive features for better insights and decision-making
- [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
+- [**VNote**](https://github.com/vnotex/vnote/blob/master/src/core/services/notebookcoreservice.cpp), a Markdown-based note-taking application written in C++
 ## Databases and Big Data
 - [**ADIOS2**](https://code.ornl.gov/ecpcitest/adios2/-/tree/pr4285_FFSUpstream/thirdparty/nlohmann_json?ref_type=heads), a data management framework designed for high-performance input and output operations
 - [**Apache Doris**](https://github.com/apache/doris/blob/master/be/src/runtime/be_proc_monitor.cpp), a real-time analytical database for high-concurrency queries
 - [**Claris FileMaker Server**](https://www.claris.com/company/legal/docs/acknowledgements/filemaker-server-macwin/claris_fms2025_acknowledgements_en.pdf), the server platform hosting FileMaker custom apps and databases, developed by Apple subsidiary Claris
 - [**ClickHouse**](https://github.com/ClickHouse/ClickHouse), a column-oriented database management system for real-time analytical queries
 - [**Cribl Stream**](https://docs.cribl.io/stream/third-party-current-list/), a real-time data processing platform that enables organizations to collect, route, and transform observability data, enhancing visibility and insights into their systems
 - [**DB Browser for SQLite**](https://github.com/sqlitebrowser/sqlitebrowser), a visual open-source tool for creating, designing, and editing SQLite database files
 - [**Manticore Search**](https://github.com/manticoresoftware/manticoresearch/blob/main/src/searchdhttpcompat.cpp), a database for search, offering full-text and vector queries
 - [**Milvus**](https://github.com/milvus-io/milvus/blob/master/internal/core/src/query/PlanImpl.h), a cloud-native vector database built for embedding similarity search
 - [**MongoDB**](https://github.com/mongodb/mongo/blob/master/src/mongo/replay/config_handler.cpp), a general-purpose document database
 - [**MySQL Connector/C++**](https://docs.oracle.com/cd/E17952_01/connector-cpp-9.1-license-com-en/license-opentelemetry-cpp-com.html), a C++ library for connecting and interacting with MySQL databases
 - [**MySQL NDB Cluster**](https://downloads.mysql.com/docs/licenses/cluster-9.0-com-en.pdf), a distributed database system that provides high availability and scalability for MySQL databases
 - [**MySQL Shell**](https://downloads.mysql.com/docs/licenses/mysql-shell-8.0-gpl-en.pdf), an advanced client and code editor for interacting with MySQL servers, supporting SQL, Python, and JavaScript
- [**PrestoDB**](https://github.com/prestodb/presto), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
+- [**PrestoDB**](https://github.com/prestodb/presto/blob/master/presto-native-execution/presto_cpp/main/Announcer.cpp), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
 - [**ROOT Data Analysis Framework**](https://root.cern/doc/v614/classnlohmann_1_1basic__json.html), an open-source data analysis framework widely used in high-energy physics and other fields for data processing and visualization
 - [**Typesense**](https://github.com/typesense/typesense/blob/v31/include/join.h), an open source typo-tolerant search engine
 - [**Vearch**](https://github.com/jd-opensource/vearch), a distributed vector database developed at JD.com for similarity search and retrieval-augmented generation
 - [**WiredTiger**](https://github.com/wiredtiger/wiredtiger), a high-performance storage engine for databases, offering support for compression, concurrency, and checkpointing
 ## Simulation and Modeling
 - [**Adobe Lagrange**](https://github.com/adobe/lagrange), a geometry processing library developed by Adobe for mesh manipulation and analysis
 - [**Arcturus HoloSuite**](https://www.datocms-assets.com/104353/1698904597-holosuite-third-party-software-credits-and-attributions-2.pdf), a software toolset for capturing, editing, and streaming volumetric video, featuring advanced compression technologies for high-quality 3D content creation
 - [**azul**](https://pure.tudelft.nl/ws/files/85338589/tgis.12673.pdf), a fast and efficient 3D city model viewer designed for visualizing urban environments and spatial data
 - [**Bambu Studio**](https://github.com/bambulab/BambuStudio), a slicing and print management application for Bambu Lab 3D printers
 - [**Blender**](https://projects.blender.org/blender/blender/search?q=nlohmann), a free and open-source 3D creation suite for modeling, animation, rendering, and more
 - [**cpplot**](https://cpplot.readthedocs.io/en/latest/library_api/function_eigen_8h_1ac080eac0541014c5892a55e41bf785e6.html), a library for creating interactive graphs and charts in C++, which can be viewed in web browsers
 - [**Foundry Nuke**](https://learn.foundry.com/nuke/content/misc/studio_third_party_libraries.html), a powerful node-based digital compositing and visual effects application used in film and television post-production
 - [**FreeCAD**](https://github.com/FreeCAD/FreeCAD), a free and open-source parametric 3D CAD modeler for product design and engineering
 - [**GAMS**](https://www.gams.com/47/docs/THIRDPARTY.html), a high-performance mathematical modeling system for optimization and decision support
 - [**Keysight WirelessPro**](https://docs.keysight.com/display/engdocwirelesspro/WirelessPro+2026+Release+Notes), a simulation platform for 5G, 5G-Advanced, and 6G cellular network research
 - [**Kitware SMTK**](https://github.com/Kitware/SMTK), a software toolkit for managing simulation models and workflows in scientific and engineering applications
 - [**M-Star**](https://docs.mstarcfd.com/3_Licensing/thirdparty-licenses.html), a computational fluid dynamics software for simulating and analyzing fluid flow
 - [**MapleSim CAD Toolbox**](https://www.maplesoft.com/support/help/MapleSim/view.aspx?path=CADToolbox/copyright), a software extension for MapleSim that integrates CAD models, allowing users to import, manipulate, and analyze 3D CAD data within the MapleSim environment for enhanced modeling and simulation
 - [**Microsoft AirSim**](https://github.com/microsoft/AirSim/blob/main/AirLib/include/common/Settings.hpp), a simulator for autonomous vehicles and drones built on Unreal Engine
 - [**NVIDIA Omniverse**](https://docs.omniverse.nvidia.com/composer/latest/common/product-licenses/usd-explorer/usd-explorer-2023.2.0-licenses-manifest.html), a platform for 3D content creation and collaboration that enables real-time simulations and interactive experiences across various industries
 - [**OpenSCAD**](https://github.com/openscad/openscad/blob/master/src/core/AIClient.cc), a script-driven solid 3D CAD modeller
 - [**OrcaSlicer**](https://github.com/SoftFever/OrcaSlicer), an open-source slicer supporting a wide range of consumer 3D printers
 - [**Pixar Renderman**](https://rmanwiki-26.pixar.com/space/REN26/19662083/Legal+Notice), a photorealistic 3D rendering software developed by Pixar, widely used in the film industry for creating high-quality visual effects and animations
 - [**PrusaSlicer**](https://github.com/prusa3d/PrusaSlicer), the slicing software developed by Prusa Research for its 3D printers
 - [**ROS - Robot Operating System**](http://docs.ros.org/en/noetic/api/behaviortree_cpp/html/json_8hpp_source.html), a set of software libraries and tools that assist in developing robot applications
 - [**UBS**](https://www.ubs.com/), a multinational financial services and banking company
@@ -161,18 +278,31 @@ the result of an internet search. If you know further customers of the library,
 - [**Acronis Cyber Protect Cloud**](https://care.acronis.com/s/article/59533-Third-party-software-used-in-Acronis-Cyber-Protect-Cloud?language=en_US), an all-in-one data protection solution that combines backup, disaster recovery, and cybersecurity to safeguard business data from threats like ransomware
 - [**Baereos**](https://gitlab.tiger-computing.co.uk/packages/bareos/-/blob/tiger/bullseye/third-party/CLI11/examples/json.cpp), a backup solution that provides data protection and recovery options for various environments, including physical and virtual systems
 - [**Bitdefender Home Scanner**](https://www.bitdefender.de/site/Main/view/home-scanner-open-source.html), a tool from Bitdefender that scans devices for malware and security threats, providing a safeguard against potential online dangers
 - [**Cisco MLS++**](https://github.com/cisco/mlspp), an implementation of the Messaging Layer Security protocol for end-to-end encrypted group messaging
 - [**Citrix Provisioning**](https://docs.citrix.com/en-us/provisioning/2203-ltsr/downloads/pvs-third-party-notices-2203.pdf), a solution that streamlines the delivery of virtual desktops and applications by allowing administrators to manage and provision resources efficiently across multiple environments
 - [**Citrix Virtual Apps and Desktops**](https://docs.citrix.com/en-us/citrix-virtual-apps-desktops/2305/downloads/third-party-notices-apps-and-desktops.pdf), a solution from Citrix that delivers virtual apps and desktops
 - [**Cyberarc**](https://docs.cyberark.com/Downloads/Legal/Privileged%20Session%20Manager%20for%20SSH%20Third-Party%20Notices.pdf), a security solution that specializes in privileged access management, enabling organizations to control and monitor access to critical systems and data, thereby enhancing overall cybersecurity posture
 - [**Deutsche Telekom sysrepo-plugins**](https://github.com/telekom/sysrepo-plugins), a collection of YANG datastore plugins used to manage network devices
 - [**Egnyte Desktop**](https://helpdesk.egnyte.com/hc/en-us/articles/360007071732-Third-Party-Software-Acknowledgements), a secure cloud storage solution designed for businesses, enabling file sharing, collaboration, and data management across teams while ensuring compliance and data protection
 - [**Elster**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a digital platform developed by German tax authorities for secure and efficient electronic tax filing and management using secunet protect4use
 - [**Envoy**](https://github.com/envoyproxy/envoy), a cloud-native edge and service proxy that forms the data plane of many service meshes
 - [**Ethereum Solidity**](https://github.com/ethereum/solidity), a high-level, object-oriented programming language designed for implementing smart contracts on the Ethereum platform
 - [**gVisor**](https://github.com/google/gvisor), an application kernel that provides a secure sandbox for running untrusted containers
 - [**IBM Storage Virtualize**](https://public.dhe.ibm.com/systems/support/warranty/pdfs/stgoilc/SV_for_FS_7300_v8_7_0_Base_OILC.pdf), the software powering IBM FlashSystem enterprise storage arrays
 - [**Inciga**](https://fossies.org/linux/icinga2/third-party/nlohmann_json/json.hpp), a monitoring tool for IT infrastructure, designed to provide insights into system performance and availability through customizable dashboards and alerts
 - [**Intel Accelerator Management Daemon for VMware ESXi**](https://downloadmirror.intel.com/772507/THIRD-PARTY.txt), a management tool designed for monitoring and controlling Intel hardware accelerators within VMware ESXi environments, optimizing performance and resource allocation
 - [**Juniper Identity Management Service**](https://www.juniper.net/documentation/us/en/software/jims/jims-guide/jims-guide.pdf)
 - [**Meta FBOSS**](https://github.com/facebook/fboss), the software stack that controls the network switches in Meta's data centers
 - [**Microsoft Azure IoT SDK**](https://library.e.abb.com/public/2779c5f85f30484192eb3cb3f666a201/IP%20Gateway%20Open%20License%20Declaration_9AKK108467A4095_Rev_C.pdf), a collection of tools and libraries to help developers connect, build, and deploy Internet of Things (IoT) solutions on the Azure cloud platform
 - [**Microsoft Confidential Consortium Framework**](https://github.com/microsoft/CCF), a framework for building secure, highly available applications on trusted execution environments
 - [**Microsoft WinGet**](https://github.com/microsoft/winget-cli), a command-line utility included in the Windows Package Manager
 - [**Mitsubishi Electric SECS/GEM**](https://dl.mitsubishielectric.com/dl/fa/document/manual/plc/sh082483eng/sh082483engi.pdf), the semiconductor equipment communication software running on Mitsubishi Electric C Controller and C intelligent function modules
 - [**Moxa**](https://www.moxa.com/getmedia/fbe2a0c7-8dda-4b5b-a501-15e45adebb1f/moxa-foss-statement-for-da-720-series-win-10-ltsc-21h2-declaration-v1.0.pdf), a provider of industrial networking, computing, and automation infrastructure
 - [**plexusAV**](https://www.sisme.com/media/10994/manual_plexusav-p-avn-4-form8244-c.pdf), a high-performance AV-over-IP transceiver device capable of video encoding and decoding using the IPMX standard
 - [**Pointr**](https://docs-dev.pointr.tech/docs/8.x/Developer%20Portal/Open%20Source%20Licenses/), a platform for indoor positioning and navigation solutions, offering tools and SDKs for developers to create location-based applications
 - [**secunet protect4use**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a secure, passwordless multifactor authentication solution that transforms smartphones into digital keyrings, ensuring high security for online services and digital identities
 - [**Sencore MRD 7000**](https://www.foccusdigital.com/wp-content/uploads/2025/03/MRD-7000-Manual-8175V.pdf), a professional multi-channel receiver and decoder supporting UHD and HD stream decoding
 - [**Siemens SINEC**](https://cache.industry.siemens.com/dl/files/917/109974917/att_1298783/v2/OSS_SINEC-NMS_99.pdf), a family of network management and infrastructure services for industrial networks
 - [**Toshiba Industrial Servers**](https://www.global.toshiba/content/dam/toshiba/jp/products-solutions/industrial/computer/product/server/fs20000r/pdf/FS20000R_OSS_License_6E8C5817_rev0.pdf), the FS20000R series of industrial servers for factory automation and control systems
 - [**Wazuh**](https://github.com/wazuh/wazuh/blob/main/src/data_provider/src/sysInfo.cpp), a security platform for threat detection, integrity monitoring and incident response
 - [**ZeroTier**](https://github.com/zerotier/ZeroTierOne/blob/dev/osdep/OSUtils.hpp), a software-defined networking service that creates virtual Ethernet networks
@@ -868,6 +868,12 @@ The size of an array or object in a [binary format](../features/binary_formats/i
 the size following `#` for [UBJSON](../features/binary_formats/ubjson.md)/[BJData](../features/binary_formats/bjdata.md),
 or the encoded length for [CBOR](../features/binary_formats/cbor.md).
 The exception is also thrown for a [UBJSON](../features/binary_formats/ubjson.md) array of a type that is encoded by its
 marker alone (`Z`, `T` or `F`) whose declared count exceeds 1,048,576 (`1 << 20`). Such an array has no payload, so its
 count alone decides how much memory is allocated, and a handful of bytes would otherwise describe billions of values.
 [`to_ubjson`](../api/basic_json/to_ubjson.md) writes longer arrays of these types without the size and type annotation,
 so any value it produces can still be read back.
 !!! failure "Example messages"
    ```
@@ -879,6 +885,9 @@ or the encoded length for [CBOR](../features/binary_formats/cbor.md).
    ```
    [json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size
    ```
    ```
    [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size
    ```
 ### json.exception.out_of_range.409
@@ -933,6 +942,34 @@ BSON stores the length of documents, arrays, strings, and binary values in a sig
    [`to_bson`](../api/basic_json/to_bson.md) produced documents with negative length prefixes that
    [`from_bson`](../api/basic_json/from_bson.md) rejected.
 ### json.exception.out_of_range.413
 A JSON Patch `remove` operation cannot be applied because the target location's parent is neither an object nor an array. Per [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902), a `remove` target must reference a member of an existing object or an element of an existing array; a primitive value (string, number, boolean, etc.) or `null` has no members or elements to remove.
 !!! failure "Example message"
    ```
    cannot remove value: the JSON Patch 'remove' target's parent is of type number, but must be an object or array
    ```
 !!! note
    This exception was added in version 3.13.0. Before that, this situation was silently ignored (the `remove` operation had no effect).
 ### json.exception.out_of_range.414
 A JSON Patch `move` operation's `"from"` location is a proper prefix of its `"path"` location. Per [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902) (section 4.4), a location cannot be moved into one of its own children.
 !!! failure "Example message"
    ```
    cannot move value: 'from' path '/0' is a proper prefix of 'path' '/0/0'
    ```
 !!! note
    This exception was added in version 3.13.0. Before that, this situation could succeed with a corrupted result: for an array target, removing the "from" element before the "add" step shifted subsequent indices, so "path" silently re-resolved to a different element than intended.
 ## Further exceptions
 This exception is thrown in case of errors that cannot be classified with the
@@ -296,7 +296,6 @@ nav:
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
          - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
          - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
          - 'NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_non_intrusive.md
@@ -398,6 +398,17 @@ inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
    }
 }
 template<typename ConstructibleObjectType>
 auto from_json_object_reserve(ConstructibleObjectType& obj, typename ConstructibleObjectType::size_type size, priority_tag<1> /*unused*/)
 -> decltype(obj.reserve(size), void())
 {
    obj.reserve(size);
 }
 template<typename ConstructibleObjectType>
 inline void from_json_object_reserve(ConstructibleObjectType& /*obj*/, std::size_t /*size*/, priority_tag<0> /*unused*/)
 {}
 template<typename BasicJsonType, typename ConstructibleObjectType,
         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
@@ -409,6 +420,7 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
    ConstructibleObjectType ret;
    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
    from_json_object_reserve(ret, inner_object->size(), priority_tag<1> {});
    for (const auto& p : *inner_object)
    {
        ret.emplace(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
@@ -1075,8 +1075,8 @@ char* to_chars(char* first, const char* last, FloatType value)
    }
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+    JSON_HEDLEY_DIAGNOSTIC_PUSH
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
    if (value == 0) // +-0
    {
@@ -1087,7 +1087,7 @@ char* to_chars(char* first, const char* last, FloatType value)
        return first;
    }
 #ifdef __GNUC__
-#pragma GCC diagnostic pop
+    JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
@@ -33,8 +33,8 @@
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
 #if defined(__clang__)
-    #pragma clang diagnostic push
+    JSON_HEDLEY_DIAGNOSTIC_PUSH
-    #pragma clang diagnostic ignored "-Wweak-vtables"
+    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
 #endif
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -287,5 +287,5 @@ class other_error : public exception
 NLOHMANN_JSON_NAMESPACE_END
 #if defined(__clang__)
-    #pragma clang diagnostic pop
+    JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
@@ -58,6 +58,26 @@ inline bool little_endianness(int num = 1) noexcept
    return *reinterpret_cast<char*>(&num) == 1;
 }
 /*!
@brief largest element count accepted for a UBJSON container of a valueless type
 An element of type 'Z' (null), 'T' (true) or 'F' (false) is encoded by its
 type marker alone, so an optimized container of one of those types has no
 payload at all and its declared count is the only thing that decides how much
 is allocated: `[$Z#L` followed by a large count turns some ten bytes of input
 into that many values (see #2793, which reports 35 GB and 150 seconds). Every
 other type costs at least one byte per element and is bounded by the end of
 the input.
 This is a sanity bound rather than a security boundary, and it is far above
 any container met in practice. @ref binary_writer falls back to the
 unoptimized encoding for longer containers, so that a value serialized by
 this library can always be read back.
@sa https://github.com/nlohmann/json/issues/2793
 */
 JSON_INLINE_VARIABLE constexpr std::size_t max_valueless_container_size = 1 << 20;
 ///////////////////
 // binary reader //
 ///////////////////
@@ -110,6 +130,7 @@ class binary_reader
                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
    {
        sax = sax_;
        container_stack.clear();
        bool result = false;
        switch (format)
@@ -159,6 +180,69 @@ class binary_reader
    }
  private:
    ////////////////////////
    // nested containers  //
    ////////////////////////
    /*!
    @brief a container that has been opened and not closed yet
    The binary readers do not call themselves once per nesting level. Like
    @ref parser::sax_parse_internal, which does the same for JSON text, they
    keep the containers they are inside of on a heap-allocated stack, so that
    the native call stack does not grow with the nesting depth of the input
    and a deeply nested value is bounded by memory rather than by the stack
    (see #5104).
    The members are ordered by decreasing alignment, which is the ordering that
    keeps a struct from growing as members are added to it.
    */
    struct container_frame
    {
        container_frame(const std::size_t remaining_, const bool is_object_) noexcept
            : remaining(remaining_), is_object(is_object_) {}
        /// number of elements that have not been read yet
        std::size_t remaining;
        /// whether to close this container with end_object() or end_array()
        bool is_object;
    };
    /*!
    @brief open a nested array or object
    Emits the SAX start event and records the container. This is the only
    place the binary readers start a container, so a check that rejects one
    can be made here and is then guaranteed to run before the start event.
    @param[in] is_object  whether an object (true) or an array (false) begins
    @param[in] len        number of elements the container declares
    @return whether the SAX parser accepted the start event
    */
    bool enter_container(const bool is_object, const std::size_t len)
    {
        if (JSON_HEDLEY_UNLIKELY(is_object ? !sax->start_object(len) : !sax->start_array(len)))
        {
            return false;
        }
        container_stack.emplace_back(len, is_object);
        return true;
    }
    /// @copydoc enter_container
    bool enter_array(const std::size_t len)
    {
        return enter_container(/*is_object*/false, len);
    }
    /// @copydoc enter_container
    bool enter_object(const std::size_t len)
    {
        return enter_container(/*is_object*/true, len);
    }
    //////////
    // BSON //
    //////////
@@ -491,9 +575,12 @@ class binary_reader
    @return whether a valid CBOR value was passed to the SAX parser
    */
-    bool parse_cbor_internal(const bool get_char,
+    bool parse_cbor_value(const bool get_char,
-                             const cbor_tag_handler_t tag_handler)
+                          const cbor_tag_handler_t tag_handler,
                          bool& tag_pending)
    {
        tag_pending = false;
        switch (get_char ? get() : current)
        {
            // EOF
@@ -685,37 +772,36 @@ class binary_reader
            case 0x95:
            case 0x96:
            case 0x97:
-                return get_cbor_array(
+                return enter_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
            case 0x98: // array (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && enter_array(static_cast<std::size_t>(len));
            }
            case 0x99: // array (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && enter_array(static_cast<std::size_t>(len));
            }
            case 0x9A: // array (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                std::size_t size{};
-                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size);
            }
            case 0x9B: // array (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                std::size_t size{};
-                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && enter_array(size);
            }
            case 0x9F: // array (indefinite length)
-                return get_cbor_array(detail::unknown_size(), tag_handler);
+                return enter_array(detail::unknown_size());
            // map (0x00..0x17 pairs of data items follow)
            case 0xA0:
@@ -742,36 +828,36 @@ class binary_reader
            case 0xB5:
            case 0xB6:
            case 0xB7:
-                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+                return enter_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
            case 0xB8: // map (one-byte uint8_t for n follows)
            {
                std::uint8_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && enter_object(static_cast<std::size_t>(len));
            }
            case 0xB9: // map (two-byte uint16_t for n follow)
            {
                std::uint16_t len{};
-                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+                return get_number(input_format_t::cbor, len) && enter_object(static_cast<std::size_t>(len));
            }
            case 0xBA: // map (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
                std::size_t size{};
-                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size);
            }
            case 0xBB: // map (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
                std::size_t size{};
-                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && enter_object(size);
            }
            case 0xBF: // map (indefinite length)
-                return get_cbor_object(detail::unknown_size(), tag_handler);
+                return enter_object(detail::unknown_size());
            case 0xC0: // tagged item
            case 0xC1:
@@ -855,7 +941,10 @@ class binary_reader
                            default:
                                break;
                        }
-                        return parse_cbor_internal(true, tag_handler);
+                        // the tagged value follows; it is read by the loop in
                        // parse_cbor_internal() rather than by recursing here
                        tag_pending = true;
                        return true;
                    }
                    case cbor_tag_handler_t::store:
@@ -905,7 +994,11 @@ class binary_reader
                                break;
                            }
                            default:
-                                return parse_cbor_internal(true, tag_handler);
+                            {
                                // as above, the tagged value is read by the caller
                                tag_pending = true;
                                return true;
                            }
                        }
                        get();
                        return get_cbor_binary(b) && sax->binary(b);
@@ -996,23 +1089,21 @@ class binary_reader
    }
    /*!
-    @brief reads a CBOR string
+    @brief reads a definite-length CBOR string
-    This function first reads starting bytes to determine the expected
+    Reads everything @ref get_cbor_string accepts except the indefinite-length
-    string length and then copies this number of bytes into a string.
+    form, which that function handles itself. The bytes are appended to @a
-    Additionally, CBOR's strings with indefinite lengths are supported.
+    result, so consecutive chunks of an indefinite-length string can be read
    into the same string.
-    @param[out] result  created string
+    @param[out] result  string the bytes are appended to
    @return whether string creation completed
    */
    bool get_cbor_string(string_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
        {
            return false;
        }
    @pre @a current is not EOF
    */
    bool get_cbor_string_chunk(string_t& result)
    {
        switch (current)
        {
            // UTF-8 string (0x00..0x17 bytes follow)
@@ -1068,20 +1159,6 @@ class binary_reader
                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
            }
            case 0x7F: // UTF-8 string (indefinite length)
            {
                while (get() != 0xFF)
                {
                    string_t chunk;
                    if (!get_cbor_string(chunk))
                    {
                        return false;
                    }
                    result.append(chunk);
                }
                return true;
            }
            default:
            {
                auto last_token = get_token_string();
@@ -1092,23 +1169,82 @@ class binary_reader
    }
    /*!
-    @brief reads a CBOR byte array
+    @brief reads a CBOR string
    This function first reads starting bytes to determine the expected
-    byte array length and then copies this number of bytes into the byte array.
+    string length and then copies this number of bytes into a string.
-    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+    Additionally, CBOR's strings with indefinite lengths are supported.
-    @param[out] result  created byte array
+    @param[out] result  created string
    @return whether string creation completed
    */
    bool get_cbor_string(string_t& result)
    {
        // number of indefinite-length strings that have been opened and not
        // closed yet. RFC 8949, Section 3.2.3 does not permit nesting them,
        // but this reader has always accepted it, so the open levels are
        // counted instead of recursed through, which overflowed the stack for
        // an input of repeated 0x7F bytes (see #5104). Every chunk is appended
        // to the same result, so no per-level state is needed.
        std::size_t open = 0;
        while (true)
        {
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
            {
                return false;
            }
            if (current == 0x7F) // UTF-8 string (indefinite length)
            {
                ++open;
                get();
                continue;
            }
            // a break marker closes the innermost indefinite-length string;
            // outside of one it is not a string and falls through to the error
            if (open != 0 && current == 0xFF)
            {
                if (--open == 0)
                {
                    return true;
                }
                get();
                continue;
            }
            if (JSON_HEDLEY_UNLIKELY(!get_cbor_string_chunk(result)))
            {
                return false;
            }
            if (open == 0)
            {
                return true;
            }
            get();
        }
    }
    /*!
    @brief reads a definite-length CBOR byte array
    Reads everything @ref get_cbor_binary accepts except the indefinite-length
    form, which that function handles itself. The bytes are appended to @a
    result, so consecutive chunks of an indefinite-length byte array can be
    read into the same byte array.
    @param[out] result  byte array the bytes are appended to
    @return whether byte array creation completed
    */
    bool get_cbor_binary(binary_t& result)
    {
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
        {
            return false;
        }
    @pre @a current is not EOF
    */
    bool get_cbor_binary_chunk(binary_t& result)
    {
        switch (current)
        {
            // Binary data (0x00..0x17 bytes follow)
@@ -1168,20 +1304,6 @@ class binary_reader
                       get_binary(input_format_t::cbor, len, result);
            }
            case 0x5F: // Binary data (indefinite length)
            {
                while (get() != 0xFF)
                {
                    binary_t chunk;
                    if (!get_cbor_binary(chunk))
                    {
                        return false;
                    }
                    result.insert(result.end(), chunk.begin(), chunk.end());
                }
                return true;
            }
            default:
            {
                auto last_token = get_token_string();
@@ -1191,6 +1313,63 @@ class binary_reader
        }
    }
    /*!
    @brief reads a CBOR byte array
    This function first reads starting bytes to determine the expected
    byte array length and then copies this number of bytes into the byte array.
    Additionally, CBOR's byte arrays with indefinite lengths are supported.
    @param[out] result  created byte array
    @return whether byte array creation completed
    */
    bool get_cbor_binary(binary_t& result)
    {
        // the open indefinite-length byte arrays are counted rather than
        // recursed through, for the reason given in @ref get_cbor_string
        std::size_t open = 0;
        while (true)
        {
            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
            {
                return false;
            }
            if (current == 0x5F) // Binary data (indefinite length)
            {
                ++open;
                get();
                continue;
            }
            // a break marker closes the innermost indefinite-length byte
            // array; outside of one it falls through to the error below
            if (open != 0 && current == 0xFF)
            {
                if (--open == 0)
                {
                    return true;
                }
                get();
                continue;
            }
            if (JSON_HEDLEY_UNLIKELY(!get_cbor_binary_chunk(result)))
            {
                return false;
            }
            if (open == 0)
            {
                return true;
            }
            get();
        }
    }
    /*!
    @brief narrow a definite CBOR array/map length to std::size_t
@@ -1217,96 +1396,110 @@ class binary_reader
    }
    /*!
-    @param[in] len  the length of the array or detail::unknown_size() for an
+    @brief read a CBOR value and everything nested inside it
-                    array of indefinite size
+
    Reads values until the one that was begun here is complete, resuming the
    enclosing container after each element, so that the nesting depth of the
    input costs heap rather than native stack (see #5104).
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true) or whether the last read character
                         @a current should be considered instead
    @param[in] tag_handler how CBOR tags should be treated
-    @return whether array creation completed
+
    @return whether reading the value succeeded
    */
-    bool get_cbor_array(const std::size_t len,
+    bool parse_cbor_internal(const bool get_char,
-                        const cbor_tag_handler_t tag_handler)
+                             const cbor_tag_handler_t tag_handler)
    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        // whether the next value starts at a fresh byte or at the one already
-        {
+        // read into `current`
-            return false;
+        bool fetch = get_char;
        }
-        if (len != detail::unknown_size())
+        // the key currently being read; hoisted out of the loop so that its
        // capacity is reused across elements and across nesting levels
        string_t key;
        while (true)
        {
-            for (std::size_t i = 0; i < len; ++i)
+            if (!container_stack.empty())
            {
-                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                // the reference is not held across parse_cbor_value() below,
                // which can push onto the stack and reallocate it
                container_frame& top = container_stack.back();
                bool at_end = false;
                if (top.remaining != npos)
                {
-                    return false;
+                    // definite length: the container ends once its elements
                    // have been read
                    at_end = (top.remaining == 0);
                    if (!at_end)
                    {
                        // claim the element about to be read
                        --top.remaining;
                        if (top.is_object)
                        {
                            get();
                        }
                    }
                    fetch = true;
                }
-            }
+                else
        }
        else
        {
            while (get() != 0xFF)
            {
                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
                {
-                    return false;
+                    // indefinite length: the container ends at a break marker.
                    // Testing for it consumes a byte, which is the first byte
                    // of the next element when it is not one.
                    at_end = (get() == 0xFF);
                    fetch = top.is_object;
                }
            }
        }
-        return sax->end_array();
+                if (at_end)
    }
    /*!
    @param[in] len  the length of the object or detail::unknown_size() for an
                    object of indefinite size
    @param[in] tag_handler how CBOR tags should be treated
    @return whether object creation completed
    */
    bool get_cbor_object(const std::size_t len,
                         const cbor_tag_handler_t tag_handler)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
        {
            return false;
        }
        if (len != 0)
        {
            string_t key;
            if (len != detail::unknown_size())
            {
                for (std::size_t i = 0; i < len; ++i)
                {
-                    get();
+                    const bool is_object = top.is_object;
                    container_stack.pop_back();
                    if (JSON_HEDLEY_UNLIKELY(is_object ? !sax->end_object() : !sax->end_array()))
                    {
                        return false;
                    }
                    // the value begun here is complete once its container is
                    if (container_stack.empty())
                    {
                        return true;
                    }
                    continue;
                }
                if (top.is_object)
                {
                    key.clear();
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
                    {
                        return false;
                    }
-
+                    fetch = true;
                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
                    {
                        return false;
                    }
                    key.clear();
                }
            }
            else
            {
                while (get() != 0xFF)
                {
                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
                    {
                        return false;
                    }
-                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+            // a tag is not a value of its own: read on until the tagged value
-                    {
+            bool tag_pending = false;
-                        return false;
+            do
-                    }
+            {
-                    key.clear();
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_value(fetch, tag_handler, tag_pending)))
                {
                    return false;
                }
                fetch = true;
            }
            while (tag_pending);
            // a value that opened a container left it on the stack; one that
            // did not, and that was not inside a container, was the whole value
            if (container_stack.empty())
            {
                return true;
            }
        }
        return sax->end_object();
    }
    /////////////
@@ -1316,7 +1509,17 @@ class binary_reader
    /*!
    @return whether a valid MessagePack value was passed to the SAX parser
    */
-    bool parse_msgpack_internal()
+    /*!
    @brief read one MessagePack value
    Reads a single value and passes it to the SAX parser. A value that begins
    a container is not read to its end: the container is opened with
    @ref enter_container and its elements are read by
    @ref parse_msgpack_internal, so that nesting does not consume native stack.
    @return whether reading the value succeeded
    */
    bool parse_msgpack_value()
    {
        switch (get())
        {
@@ -1472,7 +1675,7 @@ class binary_reader
            case 0x8D:
            case 0x8E:
            case 0x8F:
-                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+                return enter_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
            // fixarray
            case 0x90:
@@ -1491,7 +1694,7 @@ class binary_reader
            case 0x9D:
            case 0x9E:
            case 0x9F:
-                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+                return enter_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
            // fixstr
            case 0xA0:
@@ -1622,25 +1825,25 @@ class binary_reader
            case 0xDC: // array 16
            {
                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+                return get_number(input_format_t::msgpack, len) && enter_array(static_cast<std::size_t>(len));
            }
            case 0xDD: // array 32
            {
                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+                return get_number(input_format_t::msgpack, len) && enter_array(conditional_static_cast<std::size_t>(len));
            }
            case 0xDE: // map 16
            {
                std::uint16_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+                return get_number(input_format_t::msgpack, len) && enter_object(static_cast<std::size_t>(len));
            }
            case 0xDF: // map 32
            {
                std::uint32_t len{};
-                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+                return get_number(input_format_t::msgpack, len) && enter_object(conditional_static_cast<std::size_t>(len));
            }
            // negative fixint
@@ -1888,55 +2091,69 @@ class binary_reader
    }
    /*!
-    @param[in] len  the length of the array
+    @brief read a MessagePack value and everything nested inside it
-    @return whether array creation completed
+
    Reads values until the one that was begun here is complete, resuming the
    enclosing container each time an element ends, so that the nesting depth
    of the input costs heap rather than native stack (see #5104).
    @return whether reading the value succeeded
    */
-    bool get_msgpack_array(const std::size_t len)
+    bool parse_msgpack_internal()
    {
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        // the key currently being read; hoisted out of the loop so that its
-        {
+        // capacity is reused across elements and across nesting levels
            return false;
        }
        for (std::size_t i = 0; i < len; ++i)
        {
            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
            {
                return false;
            }
        }
        return sax->end_array();
    }
    /*!
    @param[in] len  the length of the object
    @return whether object creation completed
    */
    bool get_msgpack_object(const std::size_t len)
    {
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
        {
            return false;
        }
        string_t key;
-        for (std::size_t i = 0; i < len; ++i)
+
        while (true)
        {
-            get();
+            if (!container_stack.empty())
-            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
                // copied out before anything can push onto the stack and
                // invalidate a reference into it
                const bool is_object = container_stack.back().is_object;
                if (container_stack.back().remaining == 0)
                {
                    container_stack.pop_back();
                    if (JSON_HEDLEY_UNLIKELY(is_object ? !sax->end_object() : !sax->end_array()))
                    {
                        return false;
                    }
                    // the value begun here is complete once its container is
                    if (container_stack.empty())
                    {
                        return true;
                    }
                    continue;
                }
                // claim the element about to be read
                --container_stack.back().remaining;
                if (is_object)
                {
                    get();
                    key.clear();
                    if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
                    {
                        return false;
                    }
                }
            }
            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_value()))
            {
                return false;
            }
-            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            // a value that opened a container left it on the stack; one that
            // did not, and that was not inside a container, was the whole value
            if (container_stack.empty())
            {
-                return false;
+                return true;
            }
            key.clear();
        }
        return sax->end_object();
    }
    ////////////
@@ -2391,7 +2608,12 @@ class binary_reader
    {
        result.first = npos; // size
        result.second = 0; // type
-        bool is_ndarray = false;
+        // seed the flag with the caller's context: inside an ndarray dimension
        // vector another ndarray is not allowed, and get_ubjson_size_value()
        // rejects it up front instead of reading it and reporting afterwards.
        // Seeding it with `false` made every '#' of a "[#[#[..." chain descend
        // another level, which overflowed the stack (see #5104).
        bool is_ndarray = inside_ndarray;
        get_ignore_noop();
@@ -2424,13 +2646,11 @@ class binary_reader
            }
            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
-            if (input_format == input_format_t::bjdata && is_ndarray)
+            // an ndarray was read here only if the flag flipped; when it was
            // seeded true, get_ubjson_size_value() already rejected the nested
            // dimension vector
            if (input_format == input_format_t::bjdata && is_ndarray && !inside_ndarray)
            {
                if (inside_ndarray)
                {
                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
                }
                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
            }
            return is_error;
@@ -2439,7 +2659,7 @@ class binary_reader
        if (current == '#')
        {
            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
-            if (input_format == input_format_t::bjdata && is_ndarray)
+            if (input_format == input_format_t::bjdata && is_ndarray && !inside_ndarray)
            {
                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
@@ -2710,6 +2930,17 @@ class binary_reader
        if (size_and_type.first != npos)
        {
            // reading an element of a valueless type consumes no input, so the
            // declared count alone decides how much is allocated; the check is
            // made before the start event so that no container is opened that
            // is then abandoned. See @ref max_valueless_container_size.
            if (JSON_HEDLEY_UNLIKELY((size_and_type.second == 'Z' || size_and_type.second == 'T' || size_and_type.second == 'F')
                                     && size_and_type.first > max_valueless_container_size))
            {
                return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                        exception_message(input_format, "excessive array size", "size"), nullptr));
            }
            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
            {
                return false;
@@ -3227,6 +3458,9 @@ class binary_reader
    /// the SAX parser
    json_sax_t* sax = nullptr;
    /// the containers that have been opened and not closed yet; see @ref container_frame
    std::vector<container_frame> container_stack{};
    // excluded markers in bjdata optimized type
 #define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
@@ -155,31 +155,11 @@ class input_stream_adapter
 // General-purpose iterator-based adapter. It might not be as fast as
 // theoretically possible for some containers, but it is extremely versatile.
-// SentinelType defaults to IteratorType for backward compatibility, but may be
+// SentinelType defaults to IteratorType for backward compatibility, but may
-// a different type, e.g. a C++20 sentinel such as std::default_sentinel_t when
+// be a different type (e.g., a C++20 sentinel or counted_iterator).
 // IteratorType is a std::counted_iterator.
 template<typename IteratorType, typename SentinelType = IteratorType>
 class iterator_input_adapter
 {
    // Whether the number of elements between two positions can be computed in
    // O(1): either the iterator and the sentinel have the same type (plain
    // std::distance) or, in C++20, the sentinel is a sized sentinel for the
    // iterator (std::ranges::distance), e.g. std::default_sentinel_t paired
    // with std::counted_iterator.
    //
    // JSON_HAS_RANGES gates the C++20 branch: on standard libraries with an
    // incomplete <ranges> (libstdc++ < 11, see #4440) evaluating
    // std::contiguous_iterator on a std::counted_iterator is a hard error
    // instead of yielding false, and these traits are instantiated for every
    // adapter. Such toolchains fall back to the pointer-only test and simply
    // use the byte-at-a-time scanner.
    static constexpr bool sentinel_is_sized =
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>;
 #else
        std::is_same<IteratorType, SentinelType>::value;
 #endif
  public:
    using char_type = typename std::iterator_traits<IteratorType>::value_type;
@@ -191,7 +171,7 @@ class iterator_input_adapter
    // in wide_string_input_adapter, which does not expose this).
    static constexpr bool supports_seek =
        std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-        && sentinel_is_sized
+        && std::is_same<IteratorType, SentinelType>::value
        && sizeof(char_type) == 1;
    iterator_input_adapter(IteratorType first, SentinelType last)
@@ -239,60 +219,30 @@ class iterator_input_adapter
  private:
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
-    // library iterators such as those of std::vector and std::string). The
+    // library iterators such as those of std::vector and std::string).
-    // available element count must also be computable in O(1), hence
+    // Computing the available element count needs either same-type iterators
-    // sentinel_is_sized.
+    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
-    static constexpr bool iterator_is_contiguous = sentinel_is_sized &&
+    // e.g. std::counted_iterator paired with std::default_sentinel_t.
-#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
+    static constexpr bool iterator_is_contiguous =
-        (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
 #else
-        std::is_pointer<IteratorType>::value;
+        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
 #endif
    // number of unread elements in [current, end)
    std::size_t remaining_count() const
    {
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        return static_cast<std::size_t>(std::ranges::distance(current, end));
 #else
        return static_cast<std::size_t>(std::distance(current, end));
 #endif
    }
  public:
    // Whether the remaining input is a single contiguous block of 1-byte
    // elements that the lexer can inspect directly (used for the SWAR string
    // fast path).
    static constexpr bool supports_bulk_scan =
        iterator_is_contiguous && sizeof(char_type) == 1;
    // Pointer to the next unread element; only valid when bulk_remaining() > 0.
    const char_type* bulk_data() const
    {
        return &*current;
    }
    // Number of unread elements available as one contiguous block.
    std::size_t bulk_remaining() const
    {
        return remaining_count();
    }
    // Consume @a n elements previously inspected via bulk_data().
    void bulk_skip(std::size_t n)
    {
        std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(n));
    }
  private:
    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-        const std::size_t available = remaining_count() * sizeof(char_type);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
 #else
        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
 #endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -620,46 +570,6 @@ typename iterator_input_adapter_factory<IteratorType, SentinelType>::adapter_typ
    return factory_type::create(first, last);
 }
 // The element type a container's data() points at, cv-qualifiers removed.
 // Ill-formed - and therefore SFINAE-friendly - for types without data().
 template<typename ContainerType>
 using container_data_t = typename std::remove_cv<typename std::remove_pointer <
                         decltype(std::declval<const ContainerType&>().data()) >::type >::type;
 // The container's own element type, cv-qualifiers removed. It is looked up on
 // the bare type so it is also found when ContainerType is deduced as a
 // reference by the forwarding-reference overload below.
 template<typename ContainerType>
 using container_value_t = typename std::remove_cv <
                          typename std::remove_cv<typename std::remove_reference<ContainerType>::type>::type::value_type >::type;
 // Detect a container that stores its elements contiguously as single bytes
 // (std::string, std::vector<char/unsigned char>, std::array<char, N>,
 // std::string_view, ...). Such inputs are wrapped in a pointer-based adapter so
 // they benefit from the contiguous fast paths (bulk string scanning, memcpy for
 // binary formats) in every C++ standard - not only in C++20, where the standard
 // library iterators model std::contiguous_iterator and are detected directly.
 //
 // data() and size() on their own would be duck typing: they say nothing about
 // size() counting the units data() points at, and reading [data(), data() +
 // size()) as bytes would be wrong for a type where it does not. Requiring the
 // container's own value_type to be that same single-byte element ties the two
 // together; every contiguous standard container satisfies it. Anything else
 // keeps the iterator-based adapter, which is always correct - only slower.
 template<typename ContainerType, typename = void>
 struct is_contiguous_byte_container : std::false_type {};
 template<typename ContainerType>
 struct is_contiguous_byte_container < ContainerType, void_t <
    container_data_t<ContainerType>,
    container_value_t<ContainerType>,
 decltype(std::declval<const ContainerType&>().size()) >>
            : std::integral_constant < bool,
        std::is_pointer<decltype(std::declval<const ContainerType&>().data())>::value&&
        std::is_integral<container_data_t<ContainerType>>::value&&
        sizeof(container_data_t<ContainerType>) == 1 &&
        std::is_same<container_data_t<ContainerType>, container_value_t<ContainerType>>::value > {};
 // Convenience shorthand from container to iterator
 // Enables ADL on begin(container) and end(container)
 // Encloses the using declarations in namespace for not to leak them to outside scope
@@ -687,32 +597,12 @@ struct container_input_adapter_factory< ContainerType,
 }  // namespace container_input_adapter_factory_impl
-// General container path (iterator-based). Contiguous single-byte containers
+template<typename ContainerType>
-// are excluded here and routed through the pointer-based overload below.
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType&& container)
 template < typename ContainerType,
           enable_if_t < !is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType && container)
 {
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
 }
 // Contiguous single-byte containers (std::string, std::vector<char>, ...) are
 // wrapped in a pointer-based adapter so the contiguous fast paths apply in every
 // standard. The pointer keeps the container's own element type (const char* for
 // std::string, const std::uint8_t* for std::vector<std::uint8_t>, ...), so the
 // resulting char_type - and therefore the parsing behavior - is byte-for-byte
 // identical to the iterator-based path; only the raw pointer additionally
 // enables the bulk fast paths. The container outlives the adapter for the whole
 // parse (temporaries live until the end of the full expression), exactly as the
 // iterators it replaces did.
 template < typename ContainerType,
           enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 auto input_adapter(const ContainerType& container)
 -> decltype(input_adapter(container.data(), container.data() + container.size()))
 {
    return input_adapter(container.data(), container.data() + container.size());
 }
 // specialization for std::string
 using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
@@ -19,9 +19,7 @@
 #include <vector> // vector
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/number_parse.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
 #include <nlohmann/detail/input/string_scan.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
@@ -127,25 +125,6 @@ constexpr bool input_adapter_supports_seek(std::false_type /*detected*/)
    return false;
 }
 // Detect whether an input adapter exposes a contiguous byte block that the
 // lexer can scan directly (see iterator_input_adapter::supports_bulk_scan).
 // Adapters without the flag - file, stream, wide-string, user-defined - fall
 // back to the character-at-a-time string scanner.
 template<typename InputAdapterType>
 using detect_supports_bulk_scan = decltype(InputAdapterType::supports_bulk_scan);
 template<typename InputAdapterType>
 constexpr bool input_adapter_supports_bulk_scan(std::true_type /*detected*/)
 {
    return InputAdapterType::supports_bulk_scan;
 }
 template<typename InputAdapterType>
 constexpr bool input_adapter_supports_bulk_scan(std::false_type /*detected*/)
 {
    return false;
 }
 /*!
@brief lexical analysis
@@ -167,21 +146,14 @@ class lexer : public lexer_base<BasicJsonType>
    static constexpr bool lazy_token_string =
        input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});
    /// whether string scanning may bulk-consume runs of ordinary characters
    /// directly from a contiguous input buffer (SWAR fast path). This requires
    /// the token to be reconstructible lazily (lazy_token_string), so bypassing
    /// the per-character capture in get() cannot lose error diagnostics.
    static constexpr bool bulk_scan =
        lazy_token_string
        && input_adapter_supports_bulk_scan<InputAdapterType>(is_detected<detect_supports_bulk_scan, InputAdapterType> {});
  public:
    using token_type = typename lexer_base<BasicJsonType>::token_type;
-    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false, bool discard_number_values_ = false) noexcept
        : ia(std::move(adapter))
        , ignore_comments(ignore_comments_)
        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
        , discard_number_values(discard_number_values_)
    {}
    // deleted because of pointer members
@@ -294,40 +266,6 @@ class lexer : public lexer_base<BasicJsonType>
        return true;
    }
    /// contiguous input: bulk-append the run of ordinary characters and complete
    /// well-formed UTF-8 sequences starting at the current read position, leaving
    /// the first byte that needs individual handling (the closing quote, an
    /// escape, a control character, or an ill-formed UTF-8 byte) for get()
    void scan_string_bulk(std::true_type /*bulk*/)
    {
        // a pending unget must be consumed through the normal path first
        if (next_unget)
        {
            return;
        }
        const std::size_t remaining = ia.bulk_remaining();
        if (remaining == 0)
        {
            return;
        }
        const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
        const std::size_t pos = string_bulk_run(data, remaining);
        if (pos == 0)
        {
            return;
        }
        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), pos);
        ia.bulk_skip(pos);
        // the run contains no newline (all bytes < 0x20 are treated as special),
        // so only the flat character counters advance
        position.chars_read_total += pos;
        position.chars_read_current_line += pos;
    }
    /// streaming input: no bulk fast path
    void scan_string_bulk(std::false_type /*bulk*/) const noexcept {}
    /*!
    @brief scan a string literal
@@ -353,10 +291,6 @@ class lexer : public lexer_base<BasicJsonType>
        while (true)
        {
            // bulk-consume ordinary characters from contiguous input, then
            // handle the next special byte through the switch below
            scan_string_bulk(std::integral_constant<bool, bulk_scan> {});
            // get the next character
            switch (get())
            {
@@ -1075,12 +1009,6 @@ class lexer : public lexer_base<BasicJsonType>
        // changed if minus sign, decimal point, or exponent is read
        token_type number_type = token_type::value_unsigned;
        // offset just past the last mantissa byte in token_buffer (i.e. the
        // index of 'e'/'E', or the whole token when there is no exponent).
        // convert_number() uses it to count significant digits; npos means
        // "not seen an exponent yet" and is resolved at scan_number_done
        std::size_t mantissa_end = std::string::npos;
        // state (init): we just found out we need to scan a number
        switch (current)
        {
@@ -1266,9 +1194,6 @@ scan_number_decimal2:
 scan_number_exponent:
        // we just parsed an exponent
        number_type = token_type::value_float;
        // this label is reached only right after the 'e'/'E' was appended (from
        // the zero, any1, and decimal2 states), so the mantissa ends before it
        mantissa_end = token_buffer.size() - 1;
        switch (get())
        {
            case '+':
@@ -1355,147 +1280,97 @@ scan_number_done:
        // we are done scanning a number)
        unget();
-        // no exponent was scanned: the mantissa spans the whole token
+        // If the caller does not need the converted value (only whether the
-        if (mantissa_end == std::string::npos)
+        // input is syntactically valid; see json_sax_acceptor/accept()), an
        // unsigned/integer token can be reported without calling
        // strtoull()/strtoll() at all, *provided* we can already tell from
        // the digit count alone that the conversion cannot overflow 64 bits.
        // Such tokens are always finite and are accepted unconditionally by
        // the parser regardless of their actual value (parser::sax_parse_internal()
        // never checks finiteness for value_unsigned/value_integer), so the
        // classification below is all that is needed.
        //
        // A decimal number with up to 18 digits is always representable in
        // both std::uint64_t and std::int64_t (18 nines is ~1e18, well below
        // both UINT64_MAX ~1.8e19 and INT64_MAX ~9.2e18), so strtoull()/strtoll()
        // could not have set errno to ERANGE for it. Numbers with more digits
        // (rare in practice) fall through to the exact code below, unchanged,
        // so their handling -- including reclassification to value_float when
        // the value overflows 64 bits, and rejection when it is not even
        // finite as a double -- is bit-for-bit identical to before this
        // optimization.
        //
        // Note this reasons about std::uint64_t/std::int64_t, not about
        // number_unsigned_t/number_integer_t (BasicJsonType's own, possibly
        // narrower, template parameters -- e.g. std::uint32_t). That is fine
        // *only* because discard_number_values is exclusively set by
        // accept() (see json.hpp), and accept() always parses through the
        // library's own json_sax_acceptor -- never a user-supplied SAX
        // consumer -- whose number_unsigned()/number_integer()/number_float()
        // callbacks unconditionally discard their argument and return true.
        // So for every caller that can reach this branch, neither the token
        // classification below nor the eventual (possibly narrowed, and on
        // this fast path left stale/unset) value_unsigned/value_integer is
        // ever consulted -- an unsigned/integer token is accepted outright,
        // and even a >18-digit token that this fast path deliberately falls
        // through for is, once reclassified to value_float, still finite
        // (and thus accepted) for any digit count that fits in number_unsigned_t
        // or number_integer_t regardless of that type's width. If this
        // function is ever taught to run with discard_number_values true for
        // a caller that *does* read the converted value, this reasoning (and
        // the fast path below) would need to be revisited.
        if (discard_number_values)
        {
-            mantissa_end = token_buffer.size();
+            constexpr std::size_t safe_digit_count = 18;
-        }
+            if (number_type == token_type::value_unsigned && token_buffer.size() <= safe_digit_count)
        return convert_number(number_type, mantissa_end);
    }
    /*!
    @brief convert an already-validated integer token to its value
    The digit sequence in [first, last) has been validated by the caller, so a
    dedicated parser can avoid the locale/errno overhead of std::strtoull.
    @return the token type on success; token_type::uninitialized if @a
            number_type is not an integer type or the value does not fit, in
            which case the caller falls back to the floating-point conversion
            (matching the previous std::strtoull/std::strtoll behavior)
    */
    token_type convert_integer(token_type number_type, const char* first, const char* last)
    {
        if (number_type == token_type::value_unsigned)
        {
            if (parse_integer_unsigned(first, last, value_unsigned))
            {
                return token_type::value_unsigned;
            }
-        }
+            if (number_type == token_type::value_integer && token_buffer.size() - 1 <= safe_digit_count)
        else if (number_type == token_type::value_integer)
        {
            if (parse_integer_signed(first, last, value_integer))
            {
                return token_type::value_integer;
            }
        }
-        return token_type::uninitialized;
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-    }
+        errno = 0;
-    /*!
+        // try to parse integers first and fall back to floats
-    @brief check whether Clinger's fast path can still succeed for this token
+        if (number_type == token_type::value_unsigned)
    parse_float_fast() needs a significand below 2^53. A mantissa with 17 or
    more significant digits is at least 10^16 and therefore always exceeds it,
    so calling the fast path would walk the token one extra time only to
    decline before strtod has to run anyway.
    Significant digits are the mantissa's digits from the first nonzero one on;
    the sign, the decimal point, leading zeros, and the exponent do not count.
    The answer is derived from indices - the digits are not scanned again - so
    this stays off the hot path of the number scanners.
    @param[in] mantissa_end  offset just past the last mantissa byte in
                             token_buffer
    @return false if parse_float_fast() is guaranteed to decline
    */
    bool mantissa_fits_clinger(std::size_t mantissa_end) const
    {
        // 10^16 already exceeds 2^53, so 17 digits can never fit
        constexpr std::size_t limit = 17;
        const std::size_t neg = (!token_buffer.empty() && token_buffer[0] == '-') ? 1u : 0u;
        const std::size_t has_dot = (decimal_point_position != std::string::npos) ? 1u : 0u;
        // the JSON grammar restricts the integer part to "0" or [1-9][0-9]*, so
        // a leading zero can only be a lone "0", which is not significant
        const std::size_t lead_zero = (token_buffer[neg] == '0') ? 1u : 0u;
        JSON_ASSERT(mantissa_end >= neg + has_dot + lead_zero);
        std::size_t digits = mantissa_end - neg - has_dot - lead_zero;
        if (JSON_HEDLEY_LIKELY(digits < limit))
        {
-            return true;
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
        }
-        // Only a number below 1 can carry further insignificant zeros, and only
+            // we checked the number format before
-        // while the count stays at the limit does removing them change the
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-        // answer - so this loop is skipped for all but a few tokens. Note
+
-        // token_buffer holds the locale's decimal point, so the fraction is
+            if (errno != ERANGE)
        // located through decimal_point_position rather than by searching '.'.
        if (lead_zero != 0)
        {
            JSON_ASSERT(has_dot != 0); // an integer "0" cannot reach the limit
            for (std::size_t i = decimal_point_position + 1;
                    digits >= limit && i < mantissa_end && token_buffer[i] == '0'; ++i)
            {
-                --digits;
+                value_unsigned = static_cast<number_unsigned_t>(x);
                if (value_unsigned == x)
                {
                    return token_type::value_unsigned;
                }
            }
        }
-
+        else if (number_type == token_type::value_integer)
        return digits < limit;
    }
    /*!
    @brief convert the number text in token_buffer to its value and token type
    The digit sequence in token_buffer has already been validated (by the
    scan_number() state machine or by the contiguous fast path) and holds the
    locale decimal point in place of '.'. Integers are parsed first and fall
    back to floating point on overflow. This is shared so both scanners produce
    identical results.
    @param[in] mantissa_end  offset just past the last mantissa byte in
                             token_buffer (the index of 'e'/'E', or
                             token_buffer.size() when there is no exponent);
                             used to skip Clinger's fast path when it cannot
                             possibly succeed - see mantissa_fits_clinger()
    */
    token_type convert_number(token_type number_type, std::size_t mantissa_end)
    {
        const char* const num_begin = token_buffer.data();
        const char* const num_end = num_begin + token_buffer.size();
        if (number_type != token_type::value_float)
        {
-            const token_type integer_result = convert_integer(number_type, num_begin, num_end);
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
-            if (integer_result != token_type::uninitialized)
+
            // we checked the number format before
            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
            if (errno != ERANGE)
            {
-                return integer_result;
+                value_integer = static_cast<number_integer_t>(x);
                if (value_integer == x)
                {
                    return token_type::value_integer;
                }
            }
        }
        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Prefer std::from_chars
+        // integer conversion above failed
        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
        // otherwise the exact Clinger fast path (double only); otherwise the
        // locale-aware strtof/strtod.
        if (parse_float_from_chars(num_begin, num_end, value_float))
        {
            return token_type::value_float;
        }
        // Skipping a fast path that cannot succeed is lossless and saves a full
        // extra pass over the token's bytes, which otherwise shows up on
        // high-precision inputs such as canada.json
        if (mantissa_fits_clinger(mantissa_end)
                && parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
        {
            return token_type::value_float;
        }
        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        strtof(value_float, token_buffer.data(), &endptr);
        // we checked the number format before
@@ -1504,158 +1379,6 @@ scan_number_done:
        return token_type::value_float;
    }
    /*!
    @brief contiguous fast path for scanning a number
    Parses the whole number token straight from the input buffer, avoiding the
    per-character get()/add() of scan_number(). On success it fills token_buffer
    (with the locale decimal point substituted, as scan_number() does) and
    returns the token type. On anything it does not fully recognize as a
    well-formed number it makes no state change and returns
    token_type::uninitialized, so the caller falls back to scan_number(), which
    then produces the exact diagnostic. @a current is the first digit or the
    leading minus (already read); the remaining bytes are taken from the adapter.
    */
    token_type scan_number_bulk_contiguous()
    {
        // a pending unget offsets the buffer position from current; fall back
        if (next_unget)
        {
            return token_type::uninitialized;
        }
        const std::size_t rem = ia.bulk_remaining();
        if (rem == 0)
        {
            // the first digit is the last input byte; let scan_number() finish
            return token_type::uninitialized;
        }
        // the byte before the next unread one is current (contiguous input)
        const char* const data = reinterpret_cast<const char*>(ia.bulk_data()) - 1;
        const std::size_t avail = rem + 1;
        // validate + classify the number extent (mirrors scan_number()'s grammar)
        std::size_t i = 0;
        std::size_t dot_index = std::string::npos;
        token_type number_type = token_type::value_unsigned;
        if (data[0] == '-')
        {
            number_type = token_type::value_integer;
            i = 1;
            if (i >= avail)
            {
                return token_type::uninitialized;
            }
        }
        if (data[i] == '0')
        {
            ++i;
        }
        else if (data[i] >= '1' && data[i] <= '9')
        {
            ++i;
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        else
        {
            return token_type::uninitialized;
        }
        if (i < avail && data[i] == '.')
        {
            number_type = token_type::value_float;
            dot_index = i;
            ++i;
            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
            {
                return token_type::uninitialized;
            }
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        // the mantissa ends here, whether or not an exponent part follows
        const std::size_t mantissa_end = i;
        if (i < avail && (data[i] == 'e' || data[i] == 'E'))
        {
            number_type = token_type::value_float;
            ++i;
            if (i < avail && (data[i] == '+' || data[i] == '-'))
            {
                ++i;
            }
            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
            {
                return token_type::uninitialized;
            }
            while (i < avail && data[i] >= '0' && data[i] <= '9')
            {
                ++i;
            }
        }
        const std::size_t len = i;
        // reset() records where this token starts (for diagnostics), so it has
        // to run before the input position advances below
        reset();
        // An integer token needs no token_buffer: the SAX callbacks for
        // number_integer/number_unsigned take only the value, and the overflow
        // diagnostic rebuilds the text from the input. Convert straight from the
        // input buffer and leave token_buffer empty. (JSON_DIAGNOSTIC_POSITIONS
        // derives a number's start position from get_string().size(), so there
        // the token still has to be materialized.)
 #if !JSON_DIAGNOSTIC_POSITIONS
        if (number_type != token_type::value_float)
        {
            const token_type integer_result = convert_integer(number_type, data, data + len);
            if (JSON_HEDLEY_LIKELY(integer_result != token_type::uninitialized))
            {
                ia.bulk_skip(len - 1);
                position.chars_read_total += (len - 1);
                position.chars_read_current_line += (len - 1);
                return integer_result;
            }
            // The value does not fit an integer, so this token converts as a
            // float. Recording that here keeps convert_number() below from
            // repeating the integer attempt that just failed.
            number_type = token_type::value_float;
        }
 #endif
        // materialize the token exactly as scan_number() would, substituting the
        // locale decimal point so convert_number()'s strtof fallback stays valid.
        // reset() already cleared token_buffer, so append() fills it (assign() is
        // avoided because custom string_t types need not provide it)
        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), len);
        if (dot_index != std::string::npos)
        {
            token_buffer[dot_index] = static_cast<typename string_t::value_type>(decimal_point_char);
            decimal_point_position = dot_index;
        }
        ia.bulk_skip(len - 1);
        position.chars_read_total += (len - 1);
        position.chars_read_current_line += (len - 1);
        return convert_number(number_type, mantissa_end);
    }
    /// contiguous input: try the number fast path, else the byte-path scanner
    token_type scan_number_dispatch(std::true_type /*bulk*/)
    {
        const token_type t = scan_number_bulk_contiguous();
        return (t != token_type::uninitialized) ? t : scan_number();
    }
    /// streaming input: always use the byte-path scanner
    token_type scan_number_dispatch(std::false_type /*bulk*/)
    {
        return scan_number();
    }
    /*!
    @param[in] literal_text  the literal text to expect
    @param[in] length        the length of the passed literal text
@@ -1723,8 +1446,7 @@ scan_number_done:
    */
    char_int_type get()
    {
-        ++position.chars_read_total;
+        advance_position();
        ++position.chars_read_current_line;
        if (next_unget)
        {
@@ -1736,6 +1458,23 @@ scan_number_done:
            current = ia.get_character();
        }
        return track_after_read();
    }
    /// shared head of get() / get_ignoring_pending_unget(): bump the
    /// per-character position counters (line-count-on-'\n' bookkeeping is
    /// handled afterwards, in track_after_read(), once `current` is known)
    void advance_position() noexcept
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;
    }
    /// shared tail of get() / get_ignoring_pending_unget(): capture the
    /// character for error messages (if needed) and update line/column
    /// bookkeeping for the character now in `current`
    char_int_type track_after_read()
    {
        // seekable adapters reconstruct the token lazily on error (see
        // get_token_string), so the eager per-character copy is skipped
        capture_char(std::integral_constant<bool, lazy_token_string> {});
@@ -1743,15 +1482,35 @@ scan_number_done:
        if (current == '\n')
        {
            ++position.lines_read;
            // remember the column the newline was read at: chars_read_current_line
            // is about to be cleared, and a matching unget() cannot reconstruct it
            chars_read_before_newline = position.chars_read_current_line;
            position.chars_read_current_line = 0;
        }
        return current;
    }
    /*!
    @brief like get(), but for call sites that can prove no unget() is pending
    get() has to check the `next_unget` flag on every call, because a
    previous token may have ended with unget() (e.g. scan_number() always
    ungets the character that terminated the number, so the next call to
    scan() can see it again). skip_whitespace() reads that first,
    possibly-ungotten character via a plain get(), but every further
    character it reads is guaranteed to be a fresh read: nothing between
    those calls invokes unget(). This variant skips the (otherwise always
    false) next_unget branch for those calls; it is not a general
    replacement for get().
    */
    char_int_type get_ignoring_pending_unget()
    {
        JSON_ASSERT(!next_unget);
        advance_position();
        current = ia.get_character();
        return track_after_read();
    }
    /// seekable adapter: nothing to capture, the token is rebuilt on error
    void capture_char(std::true_type /*lazy*/) const noexcept {}
@@ -1779,20 +1538,12 @@ scan_number_done:
        --position.chars_read_total;
        // in case we "unget" a newline, we have to also decrement the lines_read
        // and restore the column that get() cleared when it saw the newline;
        // chars_read_current_line == 0 can only mean the last get() read one
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
            // chars_read_before_newline counts the newline itself, which is the
            // character being ungotten, hence the -1
            position.chars_read_current_line = (chars_read_before_newline > 0)
                                               ? chars_read_before_newline - 1
                                               : 0;
        }
        else
        {
@@ -1953,13 +1704,37 @@ scan_number_done:
        return true;
    }
    /// whether `current` is one of the four JSON whitespace characters
    bool current_is_whitespace() const noexcept
    {
        return current == ' ' || current == '\t' || current == '\n' || current == '\r';
    }
    void skip_whitespace()
    {
        // the first character may be a pending unget() left over from the
        // previous token (see get_ignoring_pending_unget()); every
        // subsequent character read by this loop is guaranteed fresh, since
        // nothing below calls unget()
        get();
        if (!current_is_whitespace())
        {
            return;
        }
        // this is written as an if-guarded do-while (rather than a plain
        // while loop) because that shape is what lets both GCC and Clang
        // keep the input adapter's read pointer in a register across
        // iterations; the equivalent while-loop measurably defeated that
        // optimization in testing, turning long whitespace runs (e.g. the
        // indentation of pretty-printed JSON) from a register-only loop
        // into one that reloads the pointer from memory every character
        do
        {
-            get();
+            get_ignoring_pending_unget();
        }
-        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+        while (current_is_whitespace());
    }
    token_type scan()
@@ -2035,7 +1810,7 @@ scan_number_done:
            case '7':
            case '8':
            case '9':
-                return scan_number_dispatch(std::integral_constant<bool, bulk_scan> {});
+                return scan_number();
            // end of input (the null byte is needed when parsing from
            // string literals)
@@ -2066,10 +1841,6 @@ scan_number_done:
    /// the start position of the current token
    position_t position {};
    /// the value chars_read_current_line had when the last newline was read, so
    /// that unget() can restore the column instead of leaving it at 0
    std::size_t chars_read_before_newline = 0;
    /// raw input token string for error messages; only populated for streaming
    /// adapters (seekable adapters reconstruct it lazily via token_string_start)
    std::vector<char_type> token_string {};
@@ -2099,6 +1870,13 @@ scan_number_done:
    const char_int_type decimal_point_char = '.';
    /// the position of the decimal point in the input
    std::size_t decimal_point_position = std::string::npos;
    /// whether the caller (e.g. accept()/json_sax_acceptor) only needs the
    /// token classification and never looks at the converted numeric value;
    /// when set, scan_number() may skip strtoull()/strtoll() for
    /// value_unsigned/value_integer tokens whose digit count guarantees they
    /// fit into 64 bits (see scan_number())
    const bool discard_number_values = false;
 };
 }  // namespace detail
@@ -1,302 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <array> // array
 #include <cfloat> // FLT_EVAL_METHOD
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
 #include <limits> // numeric_limits
 #include <nlohmann/detail/macro_scope.hpp>
 // std::from_chars lives in <charconv>, but being in C++17 mode does not
 // guarantee the header exists: GCC 7 sets __cplusplus to C++17 yet ships no
 // <charconv> (added in GCC 8; floating-point support in GCC 11). Guard the
 // include with __has_include so such toolchains fall back to the scalar path.
 #if defined(JSON_HAS_CPP_17) && defined(__has_include)
    #if __has_include(<charconv>)
        #include <charconv> // from_chars (only used when __cpp_lib_to_chars is defined)
        #include <system_error> // errc
    #endif
 #endif
 // This file contains the value-conversion helpers used by the lexer to turn an
 // already-validated number token into a value, without the locale/errno
 // overhead of std::strtoull/std::strtod. They are free functions so the lexer
 // stays focused on scanning; see lexer::convert_number().
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 /*!
@brief fast integer parser for an already-validated unsigned integer
 The number scanner has already checked that [first, last) is a valid JSON
 integer, so this only needs to accumulate the digits and detect overflow. This
 avoids the locale/errno machinery of std::strtoull, which dominates
 integer-heavy inputs.
@param[in]  first   pointer to the first character (a digit)
@param[in]  last    pointer past the last character
@param[out] value   the parsed value on success
@return true if the value fit into @a NumberUnsignedType; false on overflow, in
        which case the caller falls back to floating-point parsing (matching the
        previous std::strtoull behavior)
 */
 template<typename NumberUnsignedType>
 bool parse_integer_unsigned(const char* first, const char* last, NumberUnsignedType& value) noexcept
 {
    // accumulate in the widest unsigned type used by the previous strtoull
    // path so the overflow behavior is unchanged for custom number types
    std::uint64_t x = 0;
    constexpr std::uint64_t cutoff = (std::numeric_limits<std::uint64_t>::max)() / 10u;
    constexpr std::uint64_t cutlim = (std::numeric_limits<std::uint64_t>::max)() % 10u;
    for (const char* p = first; p != last; ++p)
    {
        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
        if (JSON_HEDLEY_UNLIKELY(x > cutoff || (x == cutoff && digit > cutlim)))
        {
            return false;
        }
        x = (x * 10u) + digit;
    }
    value = static_cast<NumberUnsignedType>(x);
    // reject values that do not round-trip into a narrower NumberUnsignedType
    return static_cast<std::uint64_t>(value) == x;
 }
 /*!
@brief fast integer parser for an already-validated negative integer
@param[in]  first   pointer to the leading '-'
@param[in]  last    pointer past the last character
@param[out] value   the parsed (negative) value on success
@return true on success; false on overflow (caller falls back to float)
 */
 template<typename NumberIntegerType>
 bool parse_integer_signed(const char* first, const char* last, NumberIntegerType& value) noexcept
 {
    // the state machine only reaches the signed path via a leading '-'
    JSON_ASSERT(first != last && *first == '-');
    std::uint64_t magnitude = 0;
    // |INT64_MIN| == INT64_MAX + 1; this is the largest admissible magnitude
    constexpr std::uint64_t limit = static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1u;
    for (const char* p = first + 1; p != last; ++p)
    {
        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
        if (JSON_HEDLEY_UNLIKELY(magnitude > (limit - digit) / 10u))
        {
            return false;
        }
        magnitude = (magnitude * 10u) + digit;
    }
    const std::int64_t x = (magnitude == limit)
                           ? (std::numeric_limits<std::int64_t>::min)()
                           : -static_cast<std::int64_t>(magnitude);
    value = static_cast<NumberIntegerType>(x);
    // reject values that do not round-trip into a narrower NumberIntegerType
    return static_cast<std::int64_t>(value) == x;
 }
 /*!
@brief exact fast path for parsing a `double` (Clinger's algorithm)
 For the common case - at most 19 significant digits, a decimal exponent in
 [-22, 22], and a significand below 2^53 - the value equals significand *
 10^exp computed in IEEE-754 double arithmetic, which is exact under
 round-to-nearest because both operands are exactly representable. This is the
 same fast path used by fast_float/simdjson; the general cases are left to
 std::strtod. The parser only activates for number_float_t == double; float and
 long double keep the std::strtof/std::strtold paths (see the templated overload
 below).
@param[in]  first          pointer to the first character of the number
@param[in]  last           pointer past the last character
@param[in]  decimal_point  the (locale-dependent) decimal point character
@param[out] out            the parsed value on success
@return true if the value was parsed exactly; false to fall back to strtod
 */
 template<typename DecimalPointType>
 bool parse_float_fast(const char* first, const char* last, DecimalPointType decimal_point, double& out) noexcept
 {
 #if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
    // Clinger's fast path is only exact when double operations are evaluated in
    // true double precision. On platforms that keep intermediates in extended
    // precision (e.g. the x87 FPU on 32-bit x86, where FLT_EVAL_METHOD == 2) the
    // single significand * 10^scale step is double-rounded and can be 1 ULP off,
    // so decline and let the caller fall back to the correctly-rounded
    // std::from_chars / std::strtod path.
    static_cast<void>(first);
    static_cast<void>(last);
    static_cast<void>(decimal_point);
    static_cast<void>(out);
    return false;
 #else
    static const std::array<double, 23> powers_of_ten =
    {
        {
            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
            1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
        }
    };
    const char* p = first;
    bool negative = false;
    if (p != last && (*p == '-' || *p == '+'))
    {
        negative = (*p == '-');
        ++p;
    }
    std::uint64_t significand = 0;
    int num_digits = 0;
    int fractional_digits = 0;
    bool seen_dot = false;
    bool any_digit = false;
    for (; p != last; ++p)
    {
        const char c = *p;
        if (c >= '0' && c <= '9')
        {
            any_digit = true;
            if (JSON_HEDLEY_UNLIKELY(num_digits >= 19))
            {
                return false; // significand may not fit into uint64_t
            }
            significand = (significand * 10u) + static_cast<std::uint64_t>(c - '0');
            ++num_digits;
            fractional_digits += static_cast<int>(seen_dot);
        }
        else if (static_cast<DecimalPointType>(c) == decimal_point)
        {
            if (JSON_HEDLEY_UNLIKELY(seen_dot))
            {
                return false;
            }
            seen_dot = true;
        }
        else if (c == 'e' || c == 'E')
        {
            ++p;
            break;
        }
        else
        {
            return false;
        }
    }
    if (JSON_HEDLEY_UNLIKELY(!any_digit))
    {
        return false;
    }
    int exponent = 0;
    if (p != last) // an exponent part remains
    {
        bool exp_negative = false;
        if (p != last && (*p == '-' || *p == '+'))
        {
            exp_negative = (*p == '-');
            ++p;
        }
        bool any_exp_digit = false;
        for (; p != last; ++p)
        {
            if (JSON_HEDLEY_UNLIKELY(*p < '0' || *p > '9'))
            {
                return false;
            }
            exponent = (exponent * 10) + (*p - '0');
            any_exp_digit = true;
            if (JSON_HEDLEY_UNLIKELY(exponent > 9999))
            {
                return false;
            }
        }
        if (JSON_HEDLEY_UNLIKELY(!any_exp_digit))
        {
            return false;
        }
        if (exp_negative)
        {
            exponent = -exponent;
        }
    }
    const int scale = exponent - fractional_digits;
    if (JSON_HEDLEY_UNLIKELY(significand >= (static_cast<std::uint64_t>(1) << 53)))
    {
        return false; // significand not exactly representable as double
    }
    auto result = static_cast<double>(significand);
    if (scale >= 0)
    {
        if (JSON_HEDLEY_UNLIKELY(scale > 22))
        {
            return false;
        }
        result *= powers_of_ten[static_cast<std::size_t>(scale)];
    }
    else
    {
        if (JSON_HEDLEY_UNLIKELY(-scale > 22))
        {
            return false;
        }
        result /= powers_of_ten[static_cast<std::size_t>(-scale)];
    }
    out = negative ? -result : result;
    return true;
 #endif
 }
 /// fast float path is only exact for `double`; decline for float/long double
 template<typename DecimalPointType, typename FloatType>
 bool parse_float_fast(const char* /*first*/, const char* /*last*/, DecimalPointType /*decimal_point*/, FloatType& /*out*/) noexcept
 {
    return false;
 }
 /*!
@brief parse a float with std::from_chars (Eisel-Lemire) when available
 std::from_chars is locale-independent, correctly rounded, and - via the
 Eisel-Lemire algorithm in modern standard libraries - much faster than strtod
 over the whole value range (not just the Clinger subset). It is used only when
 __cpp_lib_to_chars indicates full floating-point support and only when it
 consumes the entire token ([first, last)); a partial parse means the buffer
 uses a non-'.' locale decimal point, in which case the caller falls back to the
 locale-aware path. An under-/overflow (result_out_of_range) also declines, so
 the caller's strtod fallback supplies the well-defined ±inf/0 result the parser
 expects (side-stepping the P4168 divergence between implementations).
@return true if the value was parsed exactly and fully; false to fall back
 */
 template<typename FloatType>
 bool parse_float_from_chars(const char* first, const char* last, FloatType& out) noexcept
 {
    // JSON_HAS_CPP_17 must gate the use as well as the <charconv> include above:
    // some standard libraries (e.g. libstdc++ 15) define __cpp_lib_to_chars even
    // in C++14 mode, where <charconv> is not included.
 #if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
    const auto result = std::from_chars(first, last, out);
    return result.ec == std::errc() && result.ptr == last;
 #else
    static_cast<void>(first);
    static_cast<void>(last);
    static_cast<void>(out);
    return false;
 #endif
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -72,9 +72,10 @@ class parser
                    parser_callback_t<BasicJsonType> cb = nullptr,
                    const bool allow_exceptions_ = true,
                    const bool ignore_comments = false,
-                    const bool ignore_trailing_commas_ = false)
+                    const bool ignore_trailing_commas_ = false,
                    const bool discard_number_values_ = false)
        : callback(std::move(cb))
-        , m_lexer(std::move(adapter), ignore_comments)
+        , m_lexer(std::move(adapter), ignore_comments, discard_number_values_)
        , allow_exceptions(allow_exceptions_)
        , ignore_trailing_commas(ignore_trailing_commas_)
    {
@@ -1,293 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <cstddef> // size_t
 #include <cstdint> // uint64_t
 #include <cstring> // memcpy
 #include <nlohmann/detail/macro_scope.hpp>
 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
 // dependency: nlohmann/json itself stays header-only and the C++11 scalar
 // validator below is always available; defining JSON_USE_SIMDUTF additionally
 // requires the simdutf headers on the include path and linking the simdutf
 // library. See string_bulk_run().
 //
 // simdutf.h itself requires C++17 - it rejects older standards with an #error -
 // so the backend is only compiled in from C++17 on. Below that the macro has no
 // effect and the scalar validator is used; it accepts and rejects exactly the
 // same input, so only throughput differs. macro_scope.hpp is included above to
 // have JSON_HAS_CPP_17 available for this test.
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
    #include <simdutf.h>
 #endif
 // This file contains the byte-level string-scanning helpers used by the lexer's
 // contiguous fast path. They operate purely on raw bytes (no dependency on the
 // lexer's template parameters) so they are free functions, keeping the lexer
 // itself focused on the state machine; see lexer::scan_string_bulk().
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 // classify a single byte as needing individual string handling: the closing
 // quote, an escape, a control character, or a non-ASCII (UTF-8)
 // lead/continuation byte. Ordinary bytes (0x20..0x7F except '"' and '\\') are
 // copied verbatim, which the bulk scanner does 8 bytes at a time.
 inline bool is_string_special(unsigned char c) noexcept
 {
    return c == '\"' || c == '\\' || c < 0x20u || c >= 0x80u;
 }
 // SWAR helper: return a word whose high bit is set in every byte of @a v that
 // is_string_special(); zero if the 8 bytes are all ordinary.
 inline std::uint64_t swar_string_special(std::uint64_t v) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
    const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
    const std::uint64_t has_quote     = (q - ones) & ~q & high;
    const std::uint64_t has_backslash = (b - ones) & ~b & high;
    const std::uint64_t has_control   = (v - 0x2020202020202020ull) & ~v & high; // < 0x20
    const std::uint64_t has_non_ascii = v & high;                                // >= 0x80
    return has_quote | has_backslash | has_control | has_non_ascii;
 }
 // return the index of the first is_string_special() byte in [data, data+n), or
 // n if every byte is ordinary; scans 8 bytes at a time
 inline std::size_t find_string_special(const unsigned char* data, std::size_t n) noexcept
 {
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t word = 0;
        std::memcpy(&word, data + i, sizeof(word));
        if (swar_string_special(word) != 0)
        {
            // a special byte is in this word; locate it (endian-agnostic)
            for (std::size_t j = 0; j < 8; ++j)
            {
                if (is_string_special(data[i + j]))
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        if (is_string_special(data[i]))
        {
            return i;
        }
    }
    return n;
 }
 // classify a byte as one the serializer must NOT copy verbatim when
 // ensure_ascii is requested: the closing quote, an escape, a control character
 // (< 0x20), DEL (0x7F), or any non-ASCII byte (>= 0x80). Everything else -
 // printable ASCII except '"' and '\\' - is emitted unchanged. Note this differs
 // from is_string_special() only in that 0x7F is also a stop (it is escaped as
 // \u007f under ensure_ascii).
 inline bool is_ascii_copyable(unsigned char c) noexcept
 {
    return c >= 0x20u && c < 0x7Fu && c != '\"' && c != '\\';
 }
 // return the index of the first byte in [data, data+n) that is NOT
 // is_ascii_copyable(), or n if every byte can be copied verbatim; scans 8 bytes
 // at a time. Used by the serializer's ensure_ascii fast path.
 inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_t n) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
        const std::uint64_t stop = ((q - ones) & ~q & high)   // == '"'
                                   | ((b - ones) & ~b & high)  // == '\\'
                                   | ((d - ones) & ~d & high)  // == 0x7F
                                   | ((v - 0x2020202020202020ull) & ~v & high) // < 0x20
                                   | (v & high);               // >= 0x80
        if (stop != 0)
        {
            for (std::size_t j = 0; j < 8; ++j)
            {
                if (!is_ascii_copyable(data[i + j]))
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        if (!is_ascii_copyable(data[i]))
        {
            return i;
        }
    }
    return n;
 }
 // Validate one UTF-8 sequence at the front of [data, data+avail). Returns its
 // length (2..4) only when the bytes form a *well-formed* sequence using exactly
 // the same ranges as scan_string()'s per-byte switch, so the bulk path accepts
 // precisely what the byte path accepts. Returns 0 for anything that is invalid,
 // incomplete, or that the byte path must diagnose (the caller then defers to
 // that path, keeping error messages unchanged). Lead bytes < 0x80 are handled
 // by the caller and never passed here.
 inline std::size_t validate_one_utf8(const unsigned char* data, std::size_t avail) noexcept
 {
    const unsigned char c0 = data[0];
    if (c0 >= 0xC2 && c0 <= 0xDF)  // U+0080..U+07FF
    {
        if (avail >= 2 && data[1] >= 0x80 && data[1] <= 0xBF)
        {
            return 2;
        }
    }
    else if (c0 == 0xE0)  // U+0800..U+0FFF
    {
        if (avail >= 3 && data[1] >= 0xA0 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if ((c0 >= 0xE1 && c0 <= 0xEC) || c0 == 0xEE || c0 == 0xEF)  // U+1000..U+CFFF, U+E000..U+FFFF
    {
        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if (c0 == 0xED)  // U+D000..U+D7FF (excludes surrogates)
    {
        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0x9F && data[2] >= 0x80 && data[2] <= 0xBF)
        {
            return 3;
        }
    }
    else if (c0 == 0xF0)  // U+10000..U+3FFFF
    {
        if (avail >= 4 && data[1] >= 0x90 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    else if (c0 >= 0xF1 && c0 <= 0xF3)  // U+40000..U+FFFFF
    {
        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    else if (c0 == 0xF4)  // U+100000..U+10FFFF
    {
        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0x8F && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
        {
            return 4;
        }
    }
    return 0; // invalid, incomplete, or must be diagnosed by the byte path
 }
 // Scalar (C++11) computation of the bulk run length: the number of leading
 // bytes in [data, data+n) that are ordinary ASCII or complete well-formed UTF-8
 // sequences, stopping before the first byte that needs individual handling (the
 // closing quote, an escape, a control character, or an ill-formed/truncated
 // sequence). ASCII is skipped 8 bytes at a time.
 inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t n) noexcept
 {
    std::size_t pos = 0;
    while (pos < n)
    {
        pos += find_string_special(data + pos, n - pos);
        if (pos >= n || data[pos] < 0x80u)
        {
            break; // end of buffer, or a quote/escape/control byte
        }
        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
        if (seq == 0)
        {
            break; // ill-formed or truncated: let the byte path diagnose it
        }
        pos += seq;
    }
    return pos;
 }
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
 // Index of the first quote/escape/control byte in [data, data+n) (non-ASCII
 // bytes are *not* stops here - the whole run is handed to simdutf), or n.
 inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t n) noexcept
 {
    constexpr std::uint64_t ones = 0x0101010101010101ull;
    constexpr std::uint64_t high = 0x8080808080808080ull;
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
        std::uint64_t v = 0;
        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull;
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
        const std::uint64_t hit = ((q - ones) & ~q & high)
                                  | ((b - ones) & ~b & high)
                                  | ((v - 0x2020202020202020ull) & ~v & high);
        if (hit != 0)
        {
            for (std::size_t j = 0; j < 8; ++j)
            {
                const unsigned char c = data[i + j];
                if (c == '\"' || c == '\\' || c < 0x20u)
                {
                    return i + j;
                }
            }
        }
    }
    for (; i < n; ++i)
    {
        const unsigned char c = data[i];
        if (c == '\"' || c == '\\' || c < 0x20u)
        {
            return i;
        }
    }
    return n;
 }
 #endif
 // Backend-dispatched bulk run length. With JSON_USE_SIMDUTF the run up to the
 // next delimiter is validated in one shot by simdutf; on the rare failure the
 // scalar helper recomputes the exact valid prefix so the byte path still
 // produces the precise diagnostic. Without it, the pure scalar path is used.
 inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noexcept
 {
 #if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
    const std::size_t run = find_string_delimiter(data, n);
    if (run != 0 && simdutf::validate_utf8(reinterpret_cast<const char*>(data), run))
    {
        return run;
    }
 #endif
    return scalar_string_bulk_run(data, n);
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -18,6 +18,7 @@
 #endif
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -206,10 +207,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 // Fix: https://github.com/nlohmann/json/issues/1401
 #if defined(__clang__)
-    // Fix: https://github.com/nlohmann/json/issues/1401
+    JSON_HEDLEY_DIAGNOSTIC_PUSH
-    #pragma clang diagnostic push
+    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -224,7 +225,7 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
 #if defined(__clang__)
-    #pragma clang diagnostic pop
+    JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
 }  // namespace std
@@ -748,6 +748,20 @@ class json_pointer
                        }
                    }
                    // the reference token consists only of digits at this point (cf. checks
                    // above); however, its numeric value might not be representable, in which
                    // case array_index() would throw out_of_range.404/410 -- contains() must
                    // not throw (see #5395), so such a reference token is treated as "not found"
                    errno = 0; // strtoull() does not reset errno on success
                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
                                             || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
                    {
                        // the array index cannot be represented as size_type
                        return false;
                    }
                    const auto idx = array_index<BasicJsonType>(reference_token);
                    if (idx >= ptr->size())
                    {
@@ -826,7 +826,17 @@ class binary_writer
                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
-                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    // an optimized array of a valueless type carries no payload, so a
                    // reader has nothing but the declared count to bound the allocation
                    // by and refuses an excessive one. Write the unoptimized form for
                    // those, at one byte per element, so the result can be read back.
                    // Objects are not affected: every element is preceded by its key.
                    const bool valueless_type = (first_prefix == 'Z' || first_prefix == 'T' || first_prefix == 'F');
                    const bool excessive_valueless = valueless_type
                                                     && j.m_data.m_value.array->size() > detail::max_valueless_container_size;
                    if (same_prefix && !excessive_valueless
                            && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
                    {
                        prefix_required = false;
                        oa->write_character(to_char_type('$'));
@@ -1668,6 +1678,15 @@ class binary_writer
        CharType dtype = it->second;
        key = "_ArraySize_";
        // the dimensions are written verbatim as the header length below, so a
        // value that is not an array cannot produce a valid one: null emits 'Z'
        // and an object emits '{', neither of which a reader accepts after '#'.
        // Such an object is not a valid ndarray and falls back to a plain object.
        if (!value.at(key).is_array())
        {
            return true;
        }
        std::size_t len = (value.at(key).empty() ? 0 : 1);
        for (const auto& el : value.at(key))
        {
@@ -1841,8 +1860,8 @@ class binary_writer
    void write_compact_float(const number_float_t n, detail::input_format_t format)
    {
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
        if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                   static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -1861,7 +1880,7 @@ class binary_writer
            write_number(n);
        }
 #ifdef __GNUC__
-#pragma GCC diagnostic pop
+        JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
    }
@@ -164,11 +164,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::parser_callback_t<basic_json>cb = nullptr,
        const bool allow_exceptions = true,
        const bool ignore_comments = false,
-        const bool ignore_trailing_commas = false
+        const bool ignore_trailing_commas = false,
        const bool discard_number_values = false
    )
    {
        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
-               std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
+               std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas, discard_number_values);
    }
  private:
@@ -1335,18 +1336,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief serialization
    /// @sa https://json.nlohmann.me/api/basic_json/dump/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    string_t dump(const int indent = -1,
                  const char indent_char = ' ',
                  const bool ensure_ascii = false,
                  const error_handler_t error_handler = error_handler_t::strict) const
    {
        string_t result;
-        detail::output_string_adapter<char, string_t> string_adapter(result);
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
        serializer s(string_adapter, indent_char, error_handler);
        if (indent >= 0)
        {
-            s.dump(*this, true, ensure_ascii, static_cast<std::size_t>(indent));
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
        }
        else
        {
@@ -1358,6 +1359,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return the type of the JSON value (explicit)
    /// @sa https://json.nlohmann.me/api/basic_json/type/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr value_t type() const noexcept
    {
        return m_data.m_type;
@@ -1365,6 +1367,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether type is primitive
    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_primitive() const noexcept
    {
        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -1372,6 +1375,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether type is structured
    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_structured() const noexcept
    {
        return is_array() || is_object();
@@ -1379,6 +1383,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is null
    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_null() const noexcept
    {
        return m_data.m_type == value_t::null;
@@ -1386,6 +1391,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is a boolean
    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_boolean() const noexcept
    {
        return m_data.m_type == value_t::boolean;
@@ -1393,6 +1399,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is a number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number() const noexcept
    {
        return is_number_integer() || is_number_float();
@@ -1400,6 +1407,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is an integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_integer() const noexcept
    {
        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -1407,6 +1415,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is an unsigned integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_unsigned() const noexcept
    {
        return m_data.m_type == value_t::number_unsigned;
@@ -1414,6 +1423,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is a floating-point number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_float() const noexcept
    {
        return m_data.m_type == value_t::number_float;
@@ -1421,6 +1431,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is an object
    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_object() const noexcept
    {
        return m_data.m_type == value_t::object;
@@ -1428,6 +1439,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is an array
    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_array() const noexcept
    {
        return m_data.m_type == value_t::array;
@@ -1435,6 +1447,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is a string
    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_string() const noexcept
    {
        return m_data.m_type == value_t::string;
@@ -1442,6 +1455,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is a binary array
    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_binary() const noexcept
    {
        return m_data.m_type == value_t::binary;
@@ -1449,6 +1463,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return whether value is discarded
    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_discarded() const noexcept
    {
        return m_data.m_type == value_t::discarded;
@@ -2780,6 +2795,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief returns the number of occurrences of a key in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/count/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type count(const typename object_t::key_type& key) const
    {
        // return 0 for all nonobject types
@@ -2790,6 +2806,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/count/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type count(KeyType && key) const
    {
        // return 0 for all nonobject types
@@ -2798,6 +2815,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief check the existence of an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(const typename object_t::key_type& key) const
    {
        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -2807,6 +2825,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(KeyType && key) const
    {
        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -2814,12 +2833,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief check the existence of an element in a JSON object given a JSON pointer
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(const json_pointer& ptr) const
    {
        return ptr.contains(this);
    }
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
    {
@@ -2975,6 +2996,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief checks whether the container is empty.
    /// @sa https://json.nlohmann.me/api/basic_json/empty/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool empty() const noexcept
    {
        switch (m_data.m_type)
@@ -3014,6 +3036,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief returns the number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/size/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type size() const noexcept
    {
        switch (m_data.m_type)
@@ -3053,6 +3076,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief returns the maximum possible number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type max_size() const noexcept
    {
        switch (m_data.m_type)
@@ -3771,13 +3795,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    bool operator==(const_reference rhs) const noexcept
    {
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
        const_reference lhs = *this;
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
-#pragma GCC diagnostic pop
+        JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
    }
@@ -3864,12 +3888,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
    {
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
 #endif
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
-#pragma GCC diagnostic pop
+        JSON_HEDLEY_DIAGNOSTIC_POP
 #endif
    }
@@ -4056,8 +4080,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        o.width(0);
        // do the actual serialization
-        detail::output_stream_adapter<char> stream_adapter(o);
+        serializer s(detail::output_adapter<char>(o), o.fill());
        serializer s(stream_adapter, o.fill());
        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
        return o;
    }
@@ -4131,22 +4154,24 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename InputType>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static bool accept(InputType&& i,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
    /// @brief check if the input is valid JSON (iterator pair, or iterator+sentinel pair for C++20 ranges support)
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename IteratorType, typename SentinelType = IteratorType,
             detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
    JSON_HEDLEY_WARN_UNUSED_RESULT
    static bool accept(IteratorType first, SentinelType last,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
    JSON_HEDLEY_WARN_UNUSED_RESULT
@@ -4155,7 +4180,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
    /// @brief generate SAX events
@@ -4241,6 +4266,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief return the type as string
    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_RETURNS_NON_NULL
    const char* type_name() const noexcept
    {
@@ -4475,8 +4501,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in CBOR format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4492,8 +4521,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    template<typename T>
@@ -4518,8 +4550,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in MessagePack format
@@ -4533,8 +4568,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in MessagePack format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4549,8 +4587,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    template<typename T>
@@ -4573,8 +4614,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in UBJSON format
@@ -4588,8 +4632,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in UBJSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4604,8 +4651,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    template<typename T>
@@ -4628,8 +4678,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in BJData format
@@ -4643,8 +4696,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in BJData format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4659,8 +4715,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in BSON format
@@ -4674,8 +4733,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @brief create a JSON value from an input in BSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4690,8 +4752,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    template<typename T>
@@ -4714,8 +4779,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        return res ? result : basic_json(value_t::discarded);
+        {
            result = value_t::discarded;
        }
        return result;
    }
    /// @}
@@ -4941,6 +5009,36 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                // note erase performs range check
                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
            }
            else
            {
                // the parent of a "remove" target must be an object or array
                // (see #5396)
                JSON_THROW(out_of_range::create(413, detail::concat("cannot remove value: the JSON Patch 'remove' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
            }
        };
        // RFC 6902 (section 4.4) forbids "from" from being a proper prefix
        // of "path" for a "move" operation: a location cannot be moved into
        // one of its own children. Compares reference tokens (already
        // unescaped by json_pointer's parser) rather than the raw pointer
        // strings, since a token may itself contain an escaped '/' or '~'
        // that would defeat a naive string-prefix comparison. "from" equal
        // to "path" is *not* a proper prefix and must return false.
        const auto is_proper_prefix = [](const json_pointer & from, const json_pointer & to)
        {
            const auto from_size = from.reference_tokens.size();
            if (from_size >= to.reference_tokens.size())
            {
                return false;
            }
            for (std::size_t i = 0; i < from_size; ++i)
            {
                if (!(from.reference_tokens[i] == to.reference_tokens[i]))
                {
                    return false;
                }
            }
            return true;
        };
        // type check: top level value must be an array
@@ -5018,6 +5116,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    const auto from_path = get_value("move", "from", true).template get<string_t>();
                    json_pointer from_ptr(from_path);
                    if (JSON_HEDLEY_UNLIKELY(is_proper_prefix(from_ptr, ptr)))
                    {
                        JSON_THROW(out_of_range::create(414, detail::concat("cannot move value: 'from' path '", from_path, "' is a proper prefix of 'path' '", path, "'"), &result));
                    }
                    // the "from" location must exist - use at()
                    basic_json const v = result.at(from_ptr);
@@ -17,7 +17,7 @@
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,7 +108,10 @@
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
 #undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
 #undef JSON_HEDLEY_PREDICT_FALSE
 #undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC
@@ -2,9 +2,6 @@ cmake_minimum_required(VERSION 3.13...4.0)
 option(JSON_Valgrind    "Execute test suite with Valgrind." OFF)
 option(JSON_FastTests   "Skip expensive/slow tests." OFF)
 option(JSON_TestSimdutf "Build the unit tests against the simdutf UTF-8 validation backend." OFF)
 set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_TestSimdutf.")
 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
@@ -128,6 +125,51 @@ json_test_set_test_options(test-unicode4 TEST_PROPERTIES TIMEOUT 3000)
 # add unit tests
 #############################################################################
 # Generate the leak checks for every JSON_HEDLEY_* macro defined in
 # hedley.hpp; tests/src/unit-no-macro-leak.cpp #include-s the result after
 # nlohmann/json.hpp (see issue #5408). Using the shared
 # cmake/scripts/gen_hedley_undef_check.cmake script (also used by `make
 # update_hedley_undef`) instead of a hand-maintained list of macro names
 # means this test can never go stale after a future `make update_hedley`.
 set(hedley_hpp "${PROJECT_SOURCE_DIR}/include/nlohmann/thirdparty/hedley/hedley.hpp")
 set(hedley_undef_check_script "${PROJECT_SOURCE_DIR}/cmake/scripts/gen_hedley_undef_check.cmake")
 set(hedley_undef_checks "${PROJECT_BINARY_DIR}/include/hedley_undef_checks.inc")
 # Reconfigure whenever the vendored header or the generator script changes,
 # so a `cmake --build` after `make update_hedley` does not silently keep a
 # stale generated file around.
 set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
    "${hedley_hpp}"
    "${hedley_undef_check_script}")
 # Generate once at configure time, so the very first build (before any
 # custom-command build step has run) already has an up-to-date file.
 execute_process(
    COMMAND ${CMAKE_COMMAND}
        "-DHEDLEY_HPP=${hedley_hpp}"
        "-DOUTPUT=${hedley_undef_checks}"
        -DMODE=checks
        -P "${hedley_undef_check_script}"
    RESULT_VARIABLE hedley_undef_check_result
 )
 if(NOT hedley_undef_check_result EQUAL 0)
    message(FATAL_ERROR "Failed to generate ${hedley_undef_checks}")
 endif()
 # Also (re)generate as a build step, so an incremental build after editing
 # hedley.hpp without a full reconfigure still picks up the change.
 add_custom_command(
    OUTPUT "${hedley_undef_checks}"
    COMMAND ${CMAKE_COMMAND}
        "-DHEDLEY_HPP=${hedley_hpp}"
        "-DOUTPUT=${hedley_undef_checks}"
        -DMODE=checks
        -P "${hedley_undef_check_script}"
    DEPENDS "${hedley_hpp}" "${hedley_undef_check_script}"
    COMMENT "Generating Hedley undef leak checks"
    VERBATIM)
 add_custom_target(generate_hedley_undef_checks DEPENDS "${hedley_undef_checks}")
 if("${JSON_TestStandards}" STREQUAL "")
    set(test_cxx_standards 11 14 17 20 23)
    unset(test_force)
@@ -152,71 +194,6 @@ if(test_force)
 endif()
 message(STATUS "${msg}")
 #############################################################################
 # optionally validate UTF-8 with simdutf (JSON_USE_SIMDUTF)
 #############################################################################
 # The simdutf backend is opt-in and not vendored, so it is fetched here rather
 # than being a checked-in dependency. Everything below hangs off test_main,
 # whose usage requirements every test target inherits; the library target and
 # the installed CMake package are deliberately left untouched.
 if (JSON_TestSimdutf)
    # simdutf requires C++17, both to compile itself and to be reachable from
    # the library, which keeps its scalar validator below that. Find a tested
    # standard that satisfies it.
    set(simdutf_standard "")
    foreach(cxx_standard ${test_cxx_standards})
        if(NOT cxx_standard LESS 17 AND compiler_supports_cpp_${cxx_standard})
            set(simdutf_standard ${cxx_standard})
            break()
        endif()
    endforeach()
    if("${simdutf_standard}" STREQUAL "")
        # Building simdutf would fail outright without a C++17 compiler, and
        # even with one it would go unused if no C++17-or-later standard is
        # tested. Say so and fall back to the scalar validator rather than
        # failing the build.
        if(NOT compiler_supports_cpp_17)
            set(simdutf_reason "the compiler does not support C++17")
        else()
            set(simdutf_reason "no tested standard is C++17 or later (testing ${msg_standards})")
        endif()
        message(WARNING
            "JSON_TestSimdutf is enabled, but ${simdutf_reason}. simdutf requires C++17, so it "
            "is not fetched and JSON_USE_SIMDUTF is not defined: the tests run against the "
            "built-in scalar UTF-8 validator instead. Set JSON_TestStandards to include 17 or "
            "later, or build with a compiler that supports C++17.")
    else()
        if (CMAKE_VERSION VERSION_LESS 3.18)
            message(FATAL_ERROR "JSON_TestSimdutf requires CMake 3.18 or later (simdutf's minimum).")
        endif()
        include(FetchContent)
        # simdutf builds its tests and tools by default, and its tests pull
        # further dependencies of their own; only the library is needed here
        set(SIMDUTF_TESTS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_TOOLS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_BENCHMARKS OFF CACHE BOOL "" FORCE)
        set(SIMDUTF_ICONV OFF CACHE BOOL "" FORCE)
        FetchContent_Declare(simdutf
            URL https://github.com/simdutf/simdutf/archive/refs/tags/v${JSON_SIMDUTF_VERSION}.tar.gz
            DOWNLOAD_EXTRACT_TIMESTAMP TRUE
        )
        FetchContent_MakeAvailable(simdutf)
        target_compile_definitions(test_main PUBLIC JSON_USE_SIMDUTF)
        target_link_libraries(test_main PUBLIC simdutf::simdutf)
        # simdutf.h requires C++17; below that the library keeps its scalar
        # validator, so any C++11/14 test targets exercise the fallback and the
        # C++17-and-later ones exercise simdutf. Both must agree.
        message(STATUS "UTF-8 validation delegated to simdutf ${JSON_SIMDUTF_VERSION} for C++17 and later (JSON_USE_SIMDUTF)")
    endif()
 endif()
 # *DO* use json_test_set_test_options() above this line
 json_test_should_build_32bit_test(json_32bit_test json_32bit_test_only "${JSON_32bitTest}")
@@ -231,6 +208,14 @@ foreach(file ${files})
    json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
 endforeach()
 # tests/src/unit-no-macro-leak.cpp #include-s the generated leak-check file,
 # so its test targets must be built after generate_hedley_undef_checks.
 foreach(cxx_standard ${test_cxx_standards})
    if(TARGET test-no-macro-leak_cpp${cxx_standard})
        add_dependencies(test-no-macro-leak_cpp${cxx_standard} generate_hedley_undef_checks)
    endif()
 endforeach()
 if(json_32bit_test_only)
    # Skip all other tests in this file
    return()
@@ -81,44 +81,6 @@ BENCHMARK_CAPTURE(ParseString, signed_ints,       TEST_DATA_DIRECTORY "/regressi
 BENCHMARK_CAPTURE(ParseString, unsigned_ints,     TEST_DATA_DIRECTORY "/regression/unsigned_ints.json");
 BENCHMARK_CAPTURE(ParseString, small_signed_ints, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json");
 //////////////////////////////////////////////////////////////////////////////
 // parse pretty-printed JSON from string
 //
 // Every file in the corpus above is minified or only lightly spaced, so none of
 // them exercise the lexer's whitespace handling. Real-world JSON is frequently
 // indented - configuration files, pretty-printed API responses, anything kept
 // under version control - where insignificant whitespace can outweigh the data.
 // Re-serializing a document with an indentation and parsing that keeps the
 // content identical to the ParseString row above, so the pair isolates the cost
 // of the whitespace alone.
 //////////////////////////////////////////////////////////////////////////////
 static void ParseIndented(benchmark::State& state, const char* filename, int indent)
 {
    std::ifstream f(filename);
    std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    const std::string indented = json::parse(str).dump(indent);
    while (state.KeepRunning())
    {
        state.PauseTiming();
        auto* j = new json();
        state.ResumeTiming();
        *j = json::parse(indented);
        state.PauseTiming();
        delete j;
        state.ResumeTiming();
    }
    state.SetBytesProcessed(state.iterations() * indented.size());
 }
 BENCHMARK_CAPTURE(ParseIndented, jeopardy / 4,     TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json",                 4);
 BENCHMARK_CAPTURE(ParseIndented, canada / 4,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json",       4);
 BENCHMARK_CAPTURE(ParseIndented, citm_catalog / 4, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", 4);
 BENCHMARK_CAPTURE(ParseIndented, twitter / 4,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json",      4);
 //////////////////////////////////////////////////////////////////////////////
 // serialize JSON
 //////////////////////////////////////////////////////////////////////////////
@@ -15,6 +15,15 @@
 namespace utils
 {
 // Some tests intentionally discard the [[nodiscard]]/JSON_HEDLEY_WARN_UNUSED_RESULT
 // return value of a call they only make to exercise its side effects (e.g. checking
 // that it does not throw). A plain (void) cast on the call expression does not
 // suppress GCC's warning for functions using the GNU __attribute__((warn_unused_result))
 // form (as opposed to the C++17 [[nodiscard]] attribute) -- passing the value into an
 // ordinary function call does.
 template<typename T>
 inline void ignore_return_value(T&& /*unused*/) noexcept {}
 inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
 {
    std::ifstream file(filename, std::ios::binary);
@@ -2751,6 +2751,31 @@ TEST_CASE("BJData")
                CHECK(json::to_bjdata(j_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, 'i', 3, ']', 1, 2, 3, 4, 5, 6}));
                CHECK(json::from_bjdata(json::to_bjdata(j_ok), true, true) == j_ok);
            }
            SECTION("ndarray whose _ArraySize_ is not an array stays as object")
            {
                // the shape is written verbatim as the header length, so a
                // value that is not an array cannot produce a valid one: null
                // would emit 'Z' and an object '{', neither of which a reader
                // accepts after '#'. Both have to stay plain objects.
                json const j_null = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", nullptr}, {"_ArrayData_", json::array()}});
                const auto out_null = json::to_bjdata(j_null);
                CHECK(out_null.at(0) == '{');
                CHECK(json::from_bjdata(out_null) == j_null);
                // an object shape passes the per-entry check by iterating its
                // values rather than dimensions, so it needs rejecting too
                json const j_obj = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {{"a", 1}}}, {"_ArrayData_", {1}}});
                const auto out_obj = json::to_bjdata(j_obj);
                CHECK(out_obj.at(0) == '{');
                CHECK(json::from_bjdata(out_obj) == j_obj);
                // a scalar shape is not a dimension list either
                json const j_num = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", 1}, {"_ArrayData_", {1}}});
                const auto out_num = json::to_bjdata(j_num);
                CHECK(out_num.at(0) == '{');
                CHECK(json::from_bjdata(out_num) == j_num);
            }
        }
    }
@@ -3263,8 +3288,10 @@ TEST_CASE("BJData")
            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR1), "[json.exception.parse_error.113] parse error at byte 6: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vR1, true, false).is_discarded());
            // a dimension vector that opens another one is rejected where the
            // nested '[' is read, rather than after it has been descended into
            std::vector<uint8_t> const vR2 = {'[', '$', 'i', '#', '[', '#', '[', 'i', 1, ']', ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 11: syntax error while parsing BJData size: expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x5D", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 7: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vR2, true, false).is_discarded());
            std::vector<uint8_t> const vR3 = {'[', '#', '[', 'i', '2', 'i', 2, ']'};
@@ -3272,7 +3299,7 @@ TEST_CASE("BJData")
            CHECK(json::from_bjdata(vR3, true, false).is_discarded());
            std::vector<uint8_t> const vR4 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', 1, ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.110] parse error at byte 14: syntax error while parsing BJData number: unexpected end of input", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vR4, true, false).is_discarded());
            std::vector<uint8_t> const vR5 = {'[', '$', 'i', '#', '[', '[', '[', ']', ']', ']'};
@@ -3280,12 +3307,25 @@ TEST_CASE("BJData")
            CHECK(json::from_bjdata(vR5, true, false).is_discarded());
            std::vector<uint8_t> const vR6 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.112] parse error at byte 14: syntax error while parsing BJData size: ndarray can not be recursive", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vR6, true, false).is_discarded());
            std::vector<uint8_t> const vH = {'[', 'H', '[', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vH), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vH, true, false).is_discarded());
            // Every "#[" of this chain used to open another dimension vector
            // and cost several stack frames before anything was rejected, so a
            // long enough chain crashed the process (see #5104). The nested
            // vector is refused where it is read, so the length is irrelevant.
            std::vector<uint8_t> vRdeep = {'['};
            for (std::size_t i = 0; i < 100000; ++i)
            {
                vRdeep.push_back('#');
                vRdeep.push_back('[');
            }
            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vRdeep), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vRdeep, true, false).is_discarded());
        }
        SECTION("objects")
@@ -38,6 +38,54 @@ class huge_binary_t : public std::vector<std::uint8_t>
 using huge_binary_json = nlohmann::basic_json <
                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
                         double, std::allocator, nlohmann::adl_serializer, huge_binary_t, void >;
 // a string type that can be made to report a size beyond INT32_MAX without
 // allocating that much memory, so BSON length overflow can be tested for
 // strings and (embedded) documents as well, following the same idea as
 // huge_binary_t.
 //
 // Unlike huge_binary_t (which is only ever used as the BSON *value* type),
 // this type doubles as basic_json's StringType and is therefore also used
 // for *object keys* (e.g. "s" or "nested" below). Only the designated test
 // value is meant to lie about its size - if every huge_string_t (including
 // keys) reported a huge size, the running totals computed while walking the
 // BSON document (see calc_bson_object_size & friends in binary_writer.hpp)
 // would need more than 32 bits, and on platforms where std::size_t is only
 // 32 bits wide that arithmetic would silently wrap around, producing wrong
 // (or even unguarded) lengths. The fake size is therefore opt-in via
 // as_huge(), and plain strings - in particular object keys - keep reporting
 // their real, small size.
 class huge_string_t : public std::string
 {
  public:
    using std::string::string;
    huge_string_t(const std::string& s) : std::string(s) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
    // returns a copy of @a s whose size() pretends to be huge
    static huge_string_t as_huge(const std::string& s)
    {
        huge_string_t result(s);
        result.pretend_huge = true;
        return result;
    }
    size_type size() const noexcept
    {
        if (pretend_huge)
        {
            // one byte more than the BSON length field can represent
            return static_cast<size_type>((std::numeric_limits<std::int32_t>::max)()) + 1;
        }
        return std::string::size();
    }
  private:
    bool pretend_huge = false;
 };
 using huge_string_json = nlohmann::basic_json <
                         std::map, std::vector, huge_string_t, bool, std::int64_t, std::uint64_t,
                         double, std::allocator, nlohmann::adl_serializer, std::vector<std::uint8_t>, void >;
 } // namespace
 TEST_CASE("BSON")
@@ -105,10 +153,36 @@ TEST_CASE("BSON")
    SECTION("lengths exceeding INT32_MAX cannot be serialized to BSON")
    {
-        huge_binary_json j;
+        // out_of_range.412 is thrown from a single shared helper
-        j["b"] = huge_binary_json::binary(huge_binary_t{});
+        // (to_bson_length) that guards the BSON length fields of binary
        // values, strings, and (embedded) documents alike
        SECTION("binary")
        {
            huge_binary_json j;
            j["b"] = huge_binary_json::binary(huge_binary_t{});
-        CHECK_THROWS_WITH_AS(huge_binary_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_binary_json::out_of_range&);
+            CHECK_THROWS_WITH_AS(huge_binary_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_binary_json::out_of_range&);
        }
        SECTION("string")
        {
            huge_string_json j;
            j["s"] = huge_string_t::as_huge("value");
            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("document")
        {
            // an oversized string nested one level deep makes the
            // *embedded* document's own length exceed INT32_MAX as well
            huge_string_json nested;
            nested["s"] = huge_string_t::as_huge("value");
            huge_string_json j;
            j["nested"] = nested;
            CHECK_THROWS_WITH_AS(huge_string_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483674 exceeds maximum of 2147483647", huge_string_json::out_of_range&);
        }
    }
    SECTION("string length must be at least 1")
@@ -193,6 +267,23 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }
        SECTION("non-empty object with bool from a non-0/1 byte (lenient parsing)")
        {
            // documented lenient behavior (see gh-5333): any non-zero byte
            // is accepted as `true`, not just 0x01
            std::vector<std::uint8_t> const input =
            {
                0x0D, 0x00, 0x00, 0x00, // size (little endian)
                0x08,               // entry: boolean
                'e', 'n', 't', 'r', 'y', '\x00',
                0x02,           // value = 0x02 (neither 0x00 nor 0x01)
                0x00                    // end marker
            };
            const json expected = { { "entry", true } };
            CHECK(json::from_bson(input) == expected);
        }
        SECTION("non-empty object with double")
        {
            json const j =
@@ -499,6 +590,29 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }
        SECTION("array elements with non-conforming keys (lenient parsing)")
        {
            // documented lenient behavior (see gh-5333): BSON array element
            // keys are not checked against the required decimal sequence
            // "0", "1", "2", ... - elements are taken in encoded order
            std::vector<std::uint8_t> const input =
            {
                0x26, 0x00, 0x00, 0x00, // size (little endian)
                0x04, 'e', 'n', 't', 'r', 'y', '\x00', // entry: embedded array
                0x1A, 0x00, 0x00, 0x00, // size (little endian)
                0x10, '5', 0x00, 0x0A, 0x00, 0x00, 0x00, // key "5" (bogus)      -> 10
                0x10, 'x', 0x00, 0x14, 0x00, 0x00, 0x00, // key "x" (non-numeric) -> 20
                0x10, '1', 0x00, 0x1E, 0x00, 0x00, 0x00, // key "1" (out of order) -> 30
                0x00, // end marker (embedded array)
                0x00 // end marker
            };
            const json expected = { { "entry", json::array({10, 20, 30}) } };
            CHECK(json::from_bson(input) == expected);
        }
        SECTION("non-empty object with binary member")
        {
            const size_t N = 10;
@@ -594,6 +708,31 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }
        SECTION("binary member with subtype 0x02 (old binary) keeps its inner length prefix (lenient parsing)")
        {
            // documented lenient behavior (see gh-5333): the payload for
            // binary subtype 0x02 ("old binary") is returned as-is,
            // including its own inner 4-byte length prefix; it is not
            // stripped or reinterpreted
            std::vector<std::uint8_t> const input =
            {
                0x17, 0x00, 0x00, 0x00, // size (little endian)
                0x05, 'e', 'n', 't', 'r', 'y', '\x00', // entry: binary
                0x06, 0x00, 0x00, 0x00, // size of binary (little endian)
                0x02, // "old binary" subtype
                0x02, 0x00, 0x00, 0x00, // inner length prefix (part of the old-binary payload)
                0x68, 0x69, // payload ('h', 'i')
                0x00 // end marker
            };
            // the inner length prefix is part of the (unmodified) payload
            const std::vector<std::uint8_t> expected_payload = {0x02, 0x00, 0x00, 0x00, 0x68, 0x69};
            const json expected = { { "entry", json::binary(expected_payload, 0x02) } };
            CHECK(json::from_bson(input) == expected);
        }
        SECTION("Some more complex document")
        {
            json const j =
@@ -2035,6 +2035,145 @@ TEST_CASE("CBOR definite length equal to the indefinite-length sentinel")
    }
 }
 TEST_CASE("CBOR nesting does not consume the call stack")
 {
    // Containers used to be read by calling back into the value reader once
    // per element, and a tag by calling it for the tagged value, so the native
    // call stack grew with the nesting depth of the input. Each of the three
    // costs a single byte to encode -- 0x9F, 0x81 and 0xC2 -- so a payload of
    // repeated bytes crashed the process (#5104). The containers are kept on a
    // heap stack now, and a tag is read in a loop.
    //
    // Deeply nested values must not be compared, copied or dumped here: those
    // operations are still recursive and would reintroduce the crash.
    json _;
    SECTION("indefinite-length containers")
    {
        const std::vector<uint8_t> input(500000, 0x9F);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
        CHECK(json::from_cbor(input, true, false).is_discarded());
    }
    SECTION("definite-length containers")
    {
        const std::vector<uint8_t> input(500000, 0x81);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
        CHECK(json::from_cbor(input, true, false).is_discarded());
    }
    SECTION("tags")
    {
        // a tag is not a value of its own, so a chain of them used to recurse
        const std::vector<uint8_t> input(500000, 0xC2);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input, true, true, json::cbor_tag_handler_t::ignore), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
        CHECK(json::from_cbor(input, true, false, json::cbor_tag_handler_t::ignore).is_discarded());
    }
    SECTION("a well-formed deep value is read through the SAX interface")
    {
        std::vector<uint8_t> input(200000, 0x9F);
        input.insert(input.end(), 200000, 0xFF);
        SaxCountdown accept_all(1000000);
        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::cbor));
    }
    SECTION("a well-formed deep value is read into a value")
    {
        const std::size_t depth = 10000;
        std::vector<uint8_t> input(depth, 0x81);
        input.push_back(0x00);
        json j = json::from_cbor(input);
        std::size_t measured = 0;
        const json* p = &j;
        while (p->is_array() && !p->empty())
        {
            p = &p->front();
            ++measured;
        }
        CHECK(measured == depth);
        CHECK(p->is_number());
    }
    SECTION("containers are still read the same way")
    {
        CHECK(json::from_cbor(std::vector<uint8_t>({0x80})) == json::array());
        CHECK(json::from_cbor(std::vector<uint8_t>({0xA0})) == json::object());
        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0xFF})) == json::array());
        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0xFF})) == json::object());
        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01, 0x02, 0xFF})) == json({1, 2}));
        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 'a', 0x01, 0xFF})) == json({{"a", 1}}));
        // definite and indefinite forms nested inside each other
        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x82, 0x01, 0x02, 0xA1, 0x61, 'k', 0xBF, 0xFF, 0xFF})) == json({{1, 2}, {{"k", json::object()}}}));
    }
    SECTION("tagged values are still read the same way")
    {
        const auto ignore = json::cbor_tag_handler_t::ignore;
        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x01}), true, true, ignore) == json(1));
        // a chain of tags resolves to the value that follows it
        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0xC2, 0xC2, 0x01}), true, true, ignore) == json(1));
        // a tag inside a container, and one in front of a container
        CHECK(json::from_cbor(std::vector<uint8_t>({0x82, 0xC2, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x82, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
    }
 }
 TEST_CASE("CBOR indefinite-length strings do not recurse per chunk")
 {
    // Reading an indefinite-length string or byte array used to call itself
    // once per chunk, so a payload of repeated 0x7F (or 0x5F) bytes exhausted
    // the call stack before any of the input was rejected. The open levels are
    // counted now, and the levels below prove the reader still reads the same
    // values and reports the same errors at the same byte offsets.
    json _;
    SECTION("many open levels are reported, not crashed on")
    {
        const std::vector<uint8_t> input(200000, 0x7F);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
        CHECK(json::from_cbor(input, true, false).is_discarded());
    }
    SECTION("many open levels are reported, not crashed on (binary)")
    {
        const std::vector<uint8_t> input(200000, 0x5F);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR binary: unexpected end of input", json::parse_error&);
        CHECK(json::from_cbor(input, true, false).is_discarded());
    }
    SECTION("chunks are still concatenated")
    {
        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0xFF})) == json(""));
        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x61, 0x61, 0xFF})) == json("a"));
        // nested indefinite-length strings are concatenated across levels
        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x61, 0x61, 0xFF, 0x61, 0x62, 0xFF})) == json("ab"));
        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x7F, 0x61, 0x7A, 0xFF, 0xFF, 0xFF})) == json("z"));
        CHECK(json::from_cbor(std::vector<uint8_t>({0xA1, 0x7F, 0x61, 0x61, 0xFF, 0x01})) == json({{"a", 1}}));
    }
    SECTION("chunks are still concatenated (binary)")
    {
        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x41, 0x61, 0xFF})) == json::binary({0x61}));
        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x41, 0x61, 0xFF, 0x41, 0x62, 0xFF})) == json::binary({0x61, 0x62}));
    }
    SECTION("a chunk that is not a string is still rejected")
    {
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x00", json::parse_error&);
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR binary: expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x00", json::parse_error&);
    }
    SECTION("a break marker outside an indefinite-length string is not a string")
    {
        // 0xFF only closes a string that was opened; on its own it is not one
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0xA1, 0xFF, 0x01})), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xFF", json::parse_error&);
    }
 }
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {
    SECTION("input from flynn")
@@ -12,11 +12,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <cstdlib> // strtod
 #include <sstream> // stringstream
 #include <string> // string
 #include <vector> // vector
 namespace
 {
 // shortcut to scan a string literal
@@ -229,431 +224,3 @@ TEST_CASE("lexer class")
        CHECK((scan_string("/**//**//**/", true) == json::lexer::token_type::end_of_input));
    }
 }
 TEST_CASE("lexer number fast path")
 {
    // The contiguous fast path (used for pointer/string input) must agree with
    // the streaming byte path (used for std::istream) on token type, numeric
    // value, and round-trip text for every well-formed number, and reject the
    // same malformed numbers with the same message.
    SECTION("contiguous vs streaming parity")
    {
        const std::vector<std::string> numbers =
        {
            "0", "-0", "1", "-1", "42", "-42", "10", "100", "1234567890",
            "0.0", "-0.0", "3.14", "-3.14", "0.5", "-0.001", "123.456789",
            "1e0", "1E0", "1e10", "1e-10", "1e+10", "1.5e3", "-2.5E-4",
            "9223372036854775807",             // INT64_MAX -> unsigned
            "9223372036854775808",             // INT64_MAX + 1 -> unsigned
            "18446744073709551615",            // UINT64_MAX -> unsigned
            "18446744073709551616",            // UINT64_MAX + 1 -> float
            "-9223372036854775808",            // INT64_MIN -> integer
            "-9223372036854775809",            // INT64_MIN - 1 -> float
            "123456789012345678901234567890",  // huge -> float
            "0.30000000000000004", "2.2250738585072014e-308", "1e308",
            // high-precision / wide-exponent values that exercise the
            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
            "1.7976931348623157e308", "1.2345678901234567e-250",
            "9007199254740993", "5e-324", "1e-320"
        };
        for (const auto& n : numbers)
        {
            const std::string doc = "[" + n + "]";
            // contiguous fast path
            const json a = json::parse(doc);
            // streaming byte path
            std::stringstream ss(doc);
            const json b = json::parse(ss);
            CAPTURE(n);
            CHECK(a == b);
            CHECK(a.dump() == b.dump());
            CHECK(a[0].type() == b[0].type());
        }
    }
    SECTION("significant-digit gate for the Clinger fast path")
    {
        // Clinger's fast path needs a significand below 2^53, so it cannot
        // succeed once the mantissa has 17 or more significant digits (the
        // significand would be at least 10^16). The lexer skips the attempt
        // there. That is only allowed to save work: every value must still come
        // out bit-exactly, and both scanners must agree. In particular the gate
        // must not fire for tokens whose leading zeros merely look like extra
        // digits - "0.1234567890123456" has 16 significant digits, not 17.
        const std::vector<std::string> numbers =
        {
            "1234567890123456",                  // 16 significant digits
            "12345678901234567",                 // 17 -> attempt skipped
            "123456789012345678",                // 18 -> attempt skipped
            "0.1234567890123456",                // 16: the leading "0" is not significant
            "0.12345678901234567",               // 17
            "0.00000000000000001",               // 1, in a long token
            "0.000000000000000012345678901234",  // 14, in a long token
            "-0.0000000000000000000001",         // 1, negative
            "1.0000000000000000",                // 17: trailing zeros are significant here
            "10000000000000000",                 // 17
            "9007199254740992",                  // 2^53
            "9007199254740993",                  // 2^53 + 1
            "-65.613616999999977",               // canada.json shape
            "1.2345678901234567e-250",           // 17 with an exponent
            "1.234567890123456e-250",            // 16 with an exponent
            "1e10", "0.0", "-0.0", "0e0", "0.000123"
        };
        for (const auto& n : numbers)
        {
            CAPTURE(n);
            const std::string doc = "[" + n + "]";
            const json a = json::parse(doc);   // contiguous fast path
            std::stringstream ss(doc);
            const json b = json::parse(ss);    // streaming byte path
            CHECK(a[0].type() == b[0].type());
            CHECK(a == b);
            if (a[0].is_number_float())
            {
                const double expected = std::strtod(n.c_str(), nullptr);
                CHECK(a[0].get<double>() == expected);
                CHECK(b[0].get<double>() == expected);
            }
        }
    }
    SECTION("token type classification")
    {
        CHECK((scan_string("0") == json::lexer::token_type::value_unsigned));
        CHECK((scan_string("-1") == json::lexer::token_type::value_integer));
        CHECK((scan_string("1.5") == json::lexer::token_type::value_float));
        CHECK((scan_string("1e5") == json::lexer::token_type::value_float));
        CHECK((scan_string("18446744073709551615") == json::lexer::token_type::value_unsigned));
        CHECK((scan_string("18446744073709551616") == json::lexer::token_type::value_float));
        CHECK((scan_string("-9223372036854775808") == json::lexer::token_type::value_integer));
        CHECK((scan_string("-9223372036854775809") == json::lexer::token_type::value_float));
    }
    SECTION("malformed numbers are rejected identically")
    {
        for (const char* bad :
                {"-", "1.", "1e", "1e+", "1.2e", "01", "-01", "1..2", "1.2.3"
                })
        {
            CAPTURE(bad);
            // the contiguous fast path must decline and let the byte path report
            const std::string doc = std::string("[") + bad + "]";
            CHECK_FALSE(json::accept(doc));
            std::stringstream ss(doc);
            CHECK_FALSE(json::accept(ss));
        }
    }
 #if !defined(JSON_NOEXCEPTION)
    // these sections parse invalid input, which aborts when exceptions are off
    SECTION("exhaustive grammar parity with the streaming path")
    {
        // The JSON number grammar is encoded twice: once as the scan_number()
        // state machine and once as the contiguous fast path. Enumerate every
        // short string over the number alphabet and require the two encodings to
        // agree exactly - on acceptance, on the reported error, and on the parsed
        // value - so they cannot drift apart.
        const std::string alphabet = "01.eE+-";
        // full outcome of parsing @a doc, so a mismatch in type, value, or error
        // message is caught, not just a mismatch in acceptance
        const auto outcome = [](const std::string & doc, bool streaming) -> std::string
        {
            try
            {
                if (streaming)
                {
                    std::stringstream ss(doc);
                    const json j = json::parse(ss);
                    return std::string(j[0].type_name()) + '|' + j.dump();
                }
                const json j = json::parse(doc);
                return std::string(j[0].type_name()) + '|' + j.dump();
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
        };
        std::vector<std::string> mismatches;
        std::vector<std::string> tokens{""};
        for (std::size_t length = 1; length <= 4; ++length)
        {
            std::vector<std::string> next;
            next.reserve(tokens.size() * alphabet.size());
            for (const auto& prefix : tokens)
            {
                for (const char c : alphabet)
                {
                    next.push_back(prefix + c);
                }
            }
            tokens = next;
            for (const auto& token : tokens)
            {
                const std::string doc = "[" + token + "]";
                if (outcome(doc, false) != outcome(doc, true))
                {
                    mismatches.push_back(doc);
                }
            }
        }
        // 7 + 49 + 343 + 2401 tokens
        CHECK(tokens.size() == 2401);
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
    SECTION("error positions match the streaming path")
    {
        // Rejecting identically is not enough: the fast path must also report the
        // error at the same position as the byte path. A number directly followed
        // by a newline is the interesting case, because the byte path reaches the
        // newline (which resets the column) and then ungets it.
        // returns the parse_error message, or "" if the document parsed
        const auto contiguous_error = [](const std::string & doc) -> std::string
        {
            try
            {
                const json j = json::parse(doc);
                static_cast<void>(j);
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
            return {};
        };
        const auto streaming_error = [](const std::string & doc) -> std::string
        {
            try
            {
                std::stringstream ss(doc);
                const json j = json::parse(ss);
                static_cast<void>(j);
            }
            catch (const json::parse_error& e)
            {
                return {e.what()};
            }
            return {};
        };
        for (const char* bad :
                {"[01\n]", "[00\n]", "[-01\n]", "{1\n}", "[1\n2]", "[1.2.3\n]",
                 "[1 \n2]", "[\n1\n2]", "1\n2", "[01\r\n]", "[1e\n]", "[-\n]"
                })
        {
            CAPTURE(bad);
            const std::string doc = bad;
            const std::string contiguous_what = contiguous_error(doc);
            CHECK_FALSE(contiguous_what.empty());
            CHECK(contiguous_what == streaming_error(doc));
        }
        // A number terminated by a newline must report the same position as the
        // same number terminated by anything else: scan_number() reads the
        // terminator and ungets it, so the reported column is the one reached
        // after the number's last character - not the 0 that an unget() across
        // the newline used to leave behind.
        CHECK(contiguous_error("[01\n]") == contiguous_error("[01 ]"));
        CHECK(contiguous_error("[01\n]") ==
              "[json.exception.parse_error.101] parse error at line 1, column 3: "
              "syntax error while parsing array - unexpected number literal; expected ']'");
        // the same for a multi-character token, where the column of the last
        // character (the '3' of "-2.5e3") differs from the column it starts at
        CHECK(contiguous_error("null -2.5e3\nfalse") == contiguous_error("null -2.5e3 false"));
        CHECK(contiguous_error("null -2.5e3\nfalse") ==
              "[json.exception.parse_error.101] parse error at line 1, column 11: "
              "syntax error while parsing value - unexpected number literal; expected end of input");
    }
 #endif
 }
 TEST_CASE("lexer string fast path")
 {
    // Build a byte string from explicit values: a hex escape in a string
    // literal swallows every following hex digit, which makes sequences like
    // "\xC3\xA9b" mean something other than they look like.
    const auto bytes = [](std::initializer_list<int> values)
    {
        std::string result;
        for (const int value : values)
        {
            result.push_back(static_cast<char>(value));
        }
        return result;
    };
 #if !defined(JSON_NOEXCEPTION)
    // the full outcome of parsing @a doc: the parsed value, or the exact error
    // message, so a mismatch in either is caught. Only usable with exceptions
    // on: parsing invalid input aborts when they are off.
    const auto outcome = [](const std::string & doc, bool streaming) -> std::string
    {
        try
        {
            if (streaming)
            {
                std::stringstream ss(doc);
                const json j = json::parse(ss);
                return j.dump();
            }
            const json j = json::parse(doc);
            return j.dump();
        }
        // not just parse_error: if a bulk scanner ever let ill-formed UTF-8
        // through, dump() would throw type_error.316, and that has to surface
        // as a reported mismatch rather than as an uncaught exception
        catch (const json::exception& e)
        {
            return {e.what()};
        }
    };
 #endif
    // once at the start of the string, once past the first 8-byte SWAR word, so
    // the bulk scanner sees each case with and without a run behind it
    const std::vector<std::size_t> offsets{0, 9};
 #if !defined(JSON_NOEXCEPTION)
    SECTION("exhaustive contiguous vs streaming parity")
    {
        // ordinary ASCII, both specials, a control byte, characters that make
        // the preceding backslash a valid escape, a UTF-8 lead byte of each
        // length, a continuation byte, and a byte that is never valid
        const std::vector<std::string> alphabet =
        {
            "a", "\"", "\\", "n", "u", "0", bytes({0x01}),
            bytes({0xC3}), bytes({0xA9}), bytes({0xE4}), bytes({0xF0}),
            bytes({0x80}), bytes({0xFF})
        };
        std::vector<std::string> mismatches;
        std::vector<std::string> tokens{""};
        for (std::size_t length = 1; length <= 3; ++length)
        {
            std::vector<std::string> next;
            next.reserve(tokens.size() * alphabet.size());
            for (const auto& prefix : tokens)
            {
                for (const auto& symbol : alphabet)
                {
                    next.push_back(prefix + symbol);
                }
            }
            tokens = next;
            for (const auto& token : tokens)
            {
                for (const std::size_t offset : offsets)
                {
                    const std::string doc = "[\"" + std::string(offset, 'a') + token + "\"]";
                    if (outcome(doc, false) != outcome(doc, true))
                    {
                        mismatches.push_back(doc);
                    }
                }
            }
        }
        // 13 + 169 + 2197 tokens, each at two offsets
        CHECK(tokens.size() == 2197);
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
    SECTION("special bytes at every offset of the SWAR stride")
    {
        // The bulk scanner consumes 8 bytes at a time and then a tail; place
        // every kind of byte that ends a run at each offset across two words,
        // so multibyte sequences also straddle the word boundary.
        const std::vector<std::string> specials =
        {
            "\"", "\\", bytes({0x01}), bytes({0x1F}), bytes({0x7F}),
            bytes({0xC3, 0xA9}), bytes({0xE4, 0xB8, 0xAD}), bytes({0xF0, 0x9F, 0x98, 0x80}),
            bytes({0xFF}), bytes({0xC3}), bytes({0xE4, 0xB8})
        };
        std::vector<std::string> mismatches;
        for (std::size_t offset = 0; offset <= 17; ++offset)
        {
            for (const auto& special : specials)
            {
                const std::string doc = "[\"" + std::string(offset, 'a') + special + "\"]";
                if (outcome(doc, false) != outcome(doc, true))
                {
                    mismatches.push_back(doc);
                }
            }
        }
        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
 #endif
    // json::accept() never throws, so the ranges stay covered without exceptions
    SECTION("UTF-8 ranges are accepted and rejected as documented")
    {
        // The bulk validator must accept exactly what the byte-at-a-time
        // scanner accepts, so pin the boundaries of every range it recognizes.
        // aggregate, only ever brace-initialized below; default member
        // initializers would stop it being an aggregate in C++11
        struct utf8_case // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
        {
            std::string sequence;
            bool valid;
            const char* description;
        };
        const std::vector<utf8_case> cases =
        {
            {bytes({0xC2, 0x80}), true, "U+0080, shortest two-byte"},
            {bytes({0xDF, 0xBF}), true, "U+07FF, longest two-byte"},
            {bytes({0xC1, 0xBF}), false, "overlong two-byte"},
            {bytes({0xC2, 0x7F}), false, "two-byte with bad continuation"},
            {bytes({0xE0, 0xA0, 0x80}), true, "U+0800, shortest three-byte"},
            {bytes({0xE0, 0x9F, 0xBF}), false, "overlong three-byte"},
            {bytes({0xED, 0x9F, 0xBF}), true, "U+D7FF, just below the surrogates"},
            {bytes({0xED, 0xA0, 0x80}), false, "surrogate U+D800"},
            {bytes({0xED, 0xBF, 0xBF}), false, "surrogate U+DFFF"},
            {bytes({0xEE, 0x80, 0x80}), true, "U+E000, just above the surrogates"},
            {bytes({0xEF, 0xBF, 0xBF}), true, "U+FFFF"},
            {bytes({0xF0, 0x90, 0x80, 0x80}), true, "U+10000, shortest four-byte"},
            {bytes({0xF0, 0x8F, 0xBF, 0xBF}), false, "overlong four-byte"},
            {bytes({0xF4, 0x8F, 0xBF, 0xBF}), true, "U+10FFFF, highest code point"},
            {bytes({0xF4, 0x90, 0x80, 0x80}), false, "above U+10FFFF"},
            {bytes({0xF5, 0x80, 0x80, 0x80}), false, "lead byte out of range"},
            {bytes({0x80}), false, "bare continuation byte"},
            {bytes({0xFF}), false, "byte that never appears in UTF-8"},
            {bytes({0xC3}), false, "truncated two-byte"},
            {bytes({0xE4, 0xB8}), false, "truncated three-byte"},
            {bytes({0xF0, 0x9F, 0x98}), false, "truncated four-byte"}
        };
        for (const auto& test_case : cases)
        {
            CAPTURE(test_case.description);
            for (const std::size_t offset : offsets)
            {
                CAPTURE(offset);
                const std::string doc = "[\"" + std::string(offset, 'a') + test_case.sequence + "\"]";
                CHECK(json::accept(doc) == test_case.valid);
 #if !defined(JSON_NOEXCEPTION)
                CHECK(outcome(doc, false) == outcome(doc, true));
 #endif
            }
        }
    }
 }
@@ -23,6 +23,8 @@ using nlohmann::json;
 #include <utility>
 #include <vector>
 #include "test_utils.hpp"
 namespace
 {
 class SaxEventLogger
@@ -624,7 +626,8 @@ TEST_CASE("parser class")
            SECTION("overflow")
            {
                // overflows during parsing yield an exception
-                CHECK_THROWS_WITH_AS(parser_helper("1.18973e+4932").empty(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
+                // empty() is nodiscard; the exception is thrown by parser_helper() itself, before empty() would run
                CHECK_THROWS_WITH_AS(utils::ignore_return_value(parser_helper("1.18973e+4932").empty()), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
            }
            SECTION("invalid numbers")
@@ -930,6 +933,98 @@ TEST_CASE("parser class")
                CHECK(accept_helper("+1") == false);
                CHECK(accept_helper("+0") == false);
            }
            SECTION("issue #5411 - skip conversion when accept() does not need the numeric value")
            {
                // lexer::scan_number() may skip strtoull()/strtoll() for
                // value_unsigned/value_integer tokens when the caller (e.g.
                // json::accept()) does not need the converted value, as long
                // as the digit count alone guarantees no 64-bit overflow (see
                // the "safe_digit_count" fast path in scan_number()). This
                // differential test checks that json::accept() (which enables
                // the fast path) and json::parse() (which never does) always
                // agree, over a corpus that exercises both the fast path
                // (<=18 digits) and the untouched, exact fallback path (>=19
                // digits) -- including reclassification of huge digit-only
                // integers to a (possibly non-finite) floating-point value.
                const std::vector<std::pair<std::string, bool>> cases =
                {
                    // normal small/large integers, both signs
                    {"0", true}, {"1", true}, {"-1", true}, {"42", true}, {"-42", true},
                    {"123456789", true}, {"-123456789", true},
                    // digit-count boundary around the 18-digit safe cutoff (both signs)
                    {std::string(17, '9'), true},
                    {std::string(18, '9'), true},
                    {std::string(19, '9'), true},
                    {std::string(20, '9'), true},
                    {"-" + std::string(17, '9'), true},
                    {"-" + std::string(18, '9'), true},
                    {"-" + std::string(19, '9'), true},
                    {"-" + std::string(20, '9'), true},
                    // 64-bit boundaries
                    {"9223372036854775807", true},    // INT64_MAX
                    {"-9223372036854775808", true},   // INT64_MIN
                    {"18446744073709551615", true},   // UINT64_MAX
                    {"18446744073709551616", true},   // UINT64_MAX + 1 (overflows uint64_t, finite double)
                    // the 28-digit example from the issue: overflows uint64_t
                    // but is finite as a double, so the scanner reclassifies
                    // it to value_float and it is accepted
                    {"9999999999999999999999999999", true},
                    // huge digit-only integers that overflow even a double -> rejected
                    {std::string(309, '9'), false},
                    {std::string(400, '9'), false},
                    {"1" + std::string(400, '0'), false},
                    // 1e999 / 1e400 style overflow -> rejected
                    {"1e999", false},
                    {"1e400", false},
                    {"-1e999", false},
                    {"1E999", false},
                    // values straddling DBL_MAX
                    {"1.7976931348623157e308", true},   // <= DBL_MAX, finite
                    {"1.7976931348623159e308", false},  // > DBL_MAX, overflows to inf
                    // a mix of other valid/invalid numeric syntax
                    {"3.14159", true},
                    {"-0.0", true},
                    {"1.0e10", true},
                    {"01", false},
                    {"-", false},
                    {"1.", false},
                    {"1e", false},
                    {"+1", false},
                };
                for (const auto& c : cases)
                {
                    const std::string& number = c.first;
                    const bool expected = c.second;
                    CAPTURE(number)
                    CAPTURE(expected)
                    // accept() takes the fast path (skips conversion when possible)
                    CHECK(json::accept(number) == expected);
                    // parse() always performs the full conversion; it must agree
                    json j;
                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter(number), nullptr, false).parse(true, j));
                    CHECK(!j.is_discarded() == expected);
                    // wrap in an array so get_token() is exercised beyond the
                    // very first (constructor-time) scan as well
                    std::string wrapped = "[";
                    wrapped += number;
                    wrapped += ",";
                    wrapped += number;
                    wrapped += "]";
                    CHECK(json::accept(wrapped) == expected);
                }
            }
        }
    }
@@ -1394,6 +1489,71 @@ TEST_CASE("parser class")
        CHECK(accept_helper("\"\\uD80C\\uFFFF\"") == false);
    }
 #if !defined(JSON_NOEXCEPTION)
    SECTION("issue #5412 - whitespace skipping bookkeeping (compact vs. pretty-printed)")
    {
        // lexer::skip_whitespace() reads its first character with get() (to
        // honor a possibly pending unget() from the previous token) and every
        // further whitespace character with get_ignoring_pending_unget() (a
        // get() variant that skips the then-always-false next_unget check).
        // This must not change the reported byte offset, line, or column of
        // a syntax error, even when a long run of whitespace containing
        // multiple newlines is skipped beforehand (as with pretty-printed
        // input). The expected values below were captured from the
        // unmodified do-while(get()) loop, so any regression that miscounts
        // characters or newlines while skipping whitespace changes them.
        const auto check_error = [](const std::string & input, std::size_t expected_byte,
                                    const std::string & expected_what)
        {
            CAPTURE(input)
            try
            {
                json _ = json::parse(input);
                FAIL_CHECK("expected a parse_error, but parsing succeeded");
            }
            catch (const json::parse_error& e)
            {
                CHECK(e.byte == expected_byte);
                CHECK(std::string(e.what()) == expected_what);
            }
        };
        // a nested document, serialized both compactly and pretty-printed
        // (dump(4)), each truncated right before the final closing '}' so
        // that the parser hits EOF after skipping all of the (in the
        // pretty-printed case, substantial) indentation whitespace
        const json doc =
        {
            {"a", 1},
            {"b", json::array({true, false, nullptr, "x"})},
            {"c", json::object({{"d", 3.14}, {"e", json::array({1, 2, 3})}})}
        };
        const std::string compact = doc.dump();
        const std::string pretty = doc.dump(4);
        check_error(compact.substr(0, compact.size() - 1), 60,
                    "[json.exception.parse_error.101] parse error at line 1, column 60: syntax error while parsing object - unexpected end of input; expected '}'");
        check_error(pretty.substr(0, pretty.size() - 1), 193,
                    "[json.exception.parse_error.101] parse error at line 17, column 1: syntax error while parsing object - unexpected end of input; expected '}'");
        // an invalid token appearing after several indented, multi-line
        // whitespace runs vs. the same document without any of that
        // whitespace
        check_error(R"({
    "a": 1,
    "b": [
        true,
        false
    ],
    "c": @
 })", 70,
                    "[json.exception.parse_error.101] parse error at line 7, column 10: syntax error while parsing value - invalid literal; last read: '\"c\": @'");
        check_error(R"({"a":1,"b":[true,false],"c":@})", 29,
                    "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing value - invalid literal; last read: '\"c\":@'");
    }
 #endif
    SECTION("tests found by mutate++")
    {
        // test case to make sure no comma precedes the first key
@@ -22,6 +22,8 @@ using nlohmann::json;
 #include <valarray>
 #include "test_utils.hpp"
 namespace
 {
 class SaxEventLogger
@@ -629,7 +631,8 @@ TEST_CASE("parser class")
            SECTION("overflow")
            {
                // overflows during parsing yield an exception
-                CHECK_THROWS_WITH_AS(parser_helper("1.18973e+4932").empty(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
+                // empty() is nodiscard; the exception is thrown by parser_helper() itself, before empty() would run
                CHECK_THROWS_WITH_AS(utils::ignore_return_value(parser_helper("1.18973e+4932").empty()), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
            }
            SECTION("invalid numbers")
@@ -98,10 +98,8 @@ void check_escaped(const char* original, const char* escaped = "", bool ensure_a
 void check_escaped(const char* original, const char* escaped, const bool ensure_ascii)
 {
    std::stringstream ss;
-    nlohmann::detail::output_stream_adapter<char> adapter(ss);
+    json::serializer s(nlohmann::detail::output_adapter<char>(ss), ' ');
    json::serializer s(adapter, ' ');
    s.dump_escaped(original, ensure_ascii);
    s.flush(); // dump_escaped writes into the serializer's internal buffer
    CHECK(ss.str() == escaped);
 }
 } // namespace
@@ -1389,6 +1389,37 @@ TEST_CASE("value conversion")
                // CHECK(m5["one"] == "eins");
            }
            SECTION("reserve is called on containers that support it (#5406)")
            {
                // build a larger object so that a missing/incorrect reserve()
                // call would be more likely to corrupt or drop elements
                json j_large;
                for (int i = 0; i < 100; ++i)
                {
                    j_large[std::to_string(i)] = i;
                }
                SECTION("std::unordered_map (supports reserve)")
                {
                    const auto m = j_large.get<std::unordered_map<std::string, int>>();
                    CHECK(m.size() == 100);
                    for (int i = 0; i < 100; ++i)
                    {
                        CHECK(m.at(std::to_string(i)) == i);
                    }
                }
                SECTION("std::map (no reserve, fallback path)")
                {
                    const auto m = j_large.get<std::map<std::string, int>>();
                    CHECK(m.size() == 100);
                    for (int i = 0; i < 100; ++i)
                    {
                        CHECK(m.at(std::to_string(i)) == i);
                    }
                }
            }
            SECTION("std::multimap")
            {
                j1.get<std::multimap<std::string, int>>();
@@ -0,0 +1,42 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  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
 // This file contains the C++17-only part of unit-items.cpp (structured
 // bindings support for json::items()). It is kept in a separate
 // translation unit so the (much larger) unit-items.cpp does not need to
 // be compiled a second time just for this one SECTION.
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_HAS_CPP_17
 #include <map>
 #include <string>
 TEST_CASE("items()")
 {
    SECTION("object")
    {
        SECTION("structured bindings")
        {
            json j = { {"A", 1}, {"B", 2} };
            std::map<std::string, int> m;
            for (auto const&[key, value] : j.items())
            {
                m.emplace(key, value);
            }
            CHECK(j.get<decltype(m)>() == m);
        }
    }
 }
 #endif
@@ -862,22 +862,6 @@ TEST_CASE("items()")
            CHECK(counter == 3);
        }
 #ifdef JSON_HAS_CPP_17
        SECTION("structured bindings")
        {
            json j = { {"A", 1}, {"B", 2} };
            std::map<std::string, int> m;
            for (auto const&[key, value] : j.items())
            {
                m.emplace(key, value);
            }
            CHECK(j.get<decltype(m)>() == m);
        }
 #endif
    }
    SECTION("const object")
@@ -1389,6 +1389,192 @@ TEST_CASE("JSON patch - add to a primitive parent (regression #4292)")
    }
 }
 TEST_CASE("JSON patch - remove with primitive or null parent (regression #5396)")
 {
    // Regression test for https://github.com/nlohmann/json/issues/5396
    //
    // RFC 6902 (§4.2) requires the target location of a "remove" operation
    // to exist. When the target's parent resolves to a primitive value or
    // null, the operation must fail. Previously operation_remove silently
    // did nothing in this case (neither the "is_object" nor the "is_array"
    // branch matched, and there was no final "else"), so the patch appeared
    // to succeed without changing the document. It now throws
    // out_of_range.413.
    SECTION("parent is a primitive (number)")
    {
        json const doc = {{"a", 1}};
        json const patch = {{{"op", "remove"}, {"path", "/a/b"}}};
 #if JSON_DIAGNOSTICS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.413] (/a) cannot remove value: the JSON Patch 'remove' target's parent is of type number, but must be an object or array", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.413] cannot remove value: the JSON Patch 'remove' target's parent is of type number, but must be an object or array", json::out_of_range&);
 #endif
    }
    SECTION("parent is a primitive (string)")
    {
        json const doc = {{"foo", {{"bar", "a string"}}}};
        json const patch = {{{"op", "remove"}, {"path", "/foo/bar/baz"}}};
 #if JSON_DIAGNOSTICS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.413] (/foo/bar) cannot remove value: the JSON Patch 'remove' target's parent is of type string, but must be an object or array", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.413] cannot remove value: the JSON Patch 'remove' target's parent is of type string, but must be an object or array", json::out_of_range&);
 #endif
    }
    SECTION("top-level document is null")
    {
        json const doc = nullptr;
        json const patch = {{{"op", "remove"}, {"path", "/a"}}};
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.413] cannot remove value: the JSON Patch 'remove' target's parent is of type null, but must be an object or array", json::out_of_range&);
    }
    SECTION("legitimate removes still work")
    {
        // object member
        json const doc1 = {{"a", 1}, {"b", 2}};
        json const patch1 = {{{"op", "remove"}, {"path", "/a"}}};
        CHECK(doc1.patch(patch1) == json({{"b", 2}}));
        // array element
        json const doc2 = R"([1, 2, 3])"_json;
        json const patch2 = {{{"op", "remove"}, {"path", "/1"}}};
        CHECK(doc2.patch(patch2) == R"([1, 3])"_json);
    }
 }
 TEST_CASE("JSON patch - move where 'from' is a proper prefix of 'path' (regression #5397)")
 {
    // Regression test for https://github.com/nlohmann/json/issues/5397
    //
    // RFC 6902 (§4.4) forbids "from" from being a proper prefix of "path"
    // for a "move" operation: "a location cannot be moved into one of its
    // children." "move" is implemented as remove-then-add; for an object
    // target this happened to throw anyway as a side effect of the "add"
    // step re-resolving through the now-removed parent, but for an array
    // target the removal shifted subsequent indices, so "path" silently
    // re-resolved to a different element and the operation "succeeded"
    // with a corrupted result. It now throws out_of_range.414 for both
    // object and array targets.
    SECTION("array target (from the issue)")
    {
        json const doc = R"([[1,2],[3]])"_json;
        json const patch = {{{"op", "move"}, {"from", "/0"}, {"path", "/0/0"}}};
 #if JSON_DIAGNOSTIC_POSITIONS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] (bytes 0-11) cannot move value: 'from' path '/0' is a proper prefix of 'path' '/0/0'", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] cannot move value: 'from' path '/0' is a proper prefix of 'path' '/0/0'", json::out_of_range&);
 #endif
    }
    SECTION("object target")
    {
        json const doc = R"({"a": {"b": 1}})"_json;
        json const patch = {{{"op", "move"}, {"from", "/a"}, {"path", "/a/b"}}};
 #if JSON_DIAGNOSTIC_POSITIONS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] (bytes 0-15) cannot move value: 'from' path '/a' is a proper prefix of 'path' '/a/b'", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] cannot move value: 'from' path '/a' is a proper prefix of 'path' '/a/b'", json::out_of_range&);
 #endif
    }
    SECTION("from == path is not a proper prefix and must not be rejected")
    {
        // "from" equal to "path" is a no-op move; it is not a *proper*
        // prefix relationship, so this new check must not reject it.
        json const doc = R"({"a": 1, "b": 2})"_json;
        json const patch = {{{"op", "move"}, {"from", "/a"}, {"path", "/a"}}};
        CHECK(doc.patch(patch) == doc);
    }
    SECTION("raw string prefix that is not a pointer-token prefix must be allowed")
    {
        // "/ab" is a string-prefix of "/abc/x" as raw text, but "ab" and
        // "abc" are different reference tokens, so this is NOT a
        // pointer-token prefix relationship and the move must succeed.
        // This is the key case proving the check compares tokens, not
        // raw pointer text (a naive std::string prefix/rfind check on
        // the undecoded pointer would wrongly reject this).
        json const doc = R"({"ab": 1, "abc": {"x": 2}})"_json;
        json const patch = {{{"op", "move"}, {"from", "/ab"}, {"path", "/abc/x"}}};
        json const result = R"({"abc": {"x": 1}})"_json;
        CHECK(doc.patch(patch) == result);
    }
    SECTION("escaped reference tokens are compared unescaped")
    {
        // "from" is the single token "a/b" (escaped as "a~1b"); "path"
        // addresses member "x" of that same value, so "from" is a
        // proper (token-level) prefix of "path" and must be rejected.
        json const doc = R"({"a/b": {"x": 1}})"_json;
        json const patch = {{{"op", "move"}, {"from", "/a~1b"}, {"path", "/a~1b/x"}}};
 #if JSON_DIAGNOSTIC_POSITIONS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] (bytes 0-17) cannot move value: 'from' path '/a~1b' is a proper prefix of 'path' '/a~1b/x'", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] cannot move value: 'from' path '/a~1b' is a proper prefix of 'path' '/a~1b/x'", json::out_of_range&);
 #endif
    }
    SECTION("ordinary valid moves still work")
    {
        // unrelated top-level members
        json const doc1 = R"({"a": 1, "b": 2})"_json;
        json const patch1 = {{{"op", "move"}, {"from", "/a"}, {"path", "/c"}}};
        CHECK(doc1.patch(patch1) == R"({"b": 2, "c": 1})"_json);
        // sibling paths that share a textual prefix but are unrelated
        json const doc2 = R"({"a": {"x": 1}, "b": {"y": 2}})"_json;
        json const patch2 = {{{"op", "move"}, {"from", "/a/x"}, {"path", "/b/z"}}};
        CHECK(doc2.patch(patch2) == R"({"a": {}, "b": {"y": 2, "z": 1}})"_json);
        // "path" is a proper prefix of "from" (the reverse relationship,
        // which RFC 6902 does not forbid)
        json const doc3 = R"({"a": {"b": 1}})"_json;
        json const patch3 = {{{"op", "move"}, {"from", "/a/b"}, {"path", "/a"}}};
        CHECK(doc3.patch(patch3) == R"({"a": 1})"_json);
    }
    SECTION("root 'from' is a proper prefix of every non-root 'path'")
    {
        // the whole document is a proper prefix of any location inside it
        json const doc = R"({"a": 1})"_json;
        json const patch = {{{"op", "move"}, {"from", ""}, {"path", "/a"}}};
 #if JSON_DIAGNOSTIC_POSITIONS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] (bytes 0-8) cannot move value: 'from' path '' is a proper prefix of 'path' '/a'", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] cannot move value: 'from' path '' is a proper prefix of 'path' '/a'", json::out_of_range&);
 #endif
    }
    SECTION("root 'path' is never a proper prefix violation for a non-root 'from'")
    {
        // the reverse of the above: moving a non-root location to the root
        // is the "path is a prefix of from" relationship, which RFC 6902
        // permits (already covered generally above; this pins the root
        // case specifically, since root is the one path with no reference
        // tokens at all)
        json const doc = R"({"a": {"b": 1}})"_json;
        json const patch = {{{"op", "move"}, {"from", "/a"}, {"path", ""}}};
        CHECK(doc.patch(patch) == R"({"b": 1})"_json);
    }
    SECTION("the array-append token '-' is an ordinary child token")
    {
        // "-" (append-to-array) addresses a location *inside* the array,
        // so "from" pointing at the array is still a proper prefix of
        // "path" ending in "-" and must be rejected like any other child.
        json const doc = R"({"a": [1, 2]})"_json;
        json const patch = {{{"op", "move"}, {"from", "/a"}, {"path", "/a/-"}}};
 #if JSON_DIAGNOSTIC_POSITIONS
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] (bytes 0-13) cannot move value: 'from' path '/a' is a proper prefix of 'path' '/a/-'", json::out_of_range&);
 #else
        CHECK_THROWS_WITH_AS(doc.patch(patch), "[json.exception.out_of_range.414] cannot move value: 'from' path '/a' is a proper prefix of 'path' '/a/-'", json::out_of_range&);
 #endif
    }
 }
 TEST_CASE("JSON patch - diff emits array removals in descending index order")
 {
    SECTION("array shrunk to empty")
@@ -319,6 +319,44 @@ TEST_CASE("JSON pointers")
                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
                // #5395: contains() must not throw for a reference token that is a
                // syntactically valid array index but numerically exceeds ULLONG_MAX
                // (causing strtoull() to set errno to ERANGE) -- it should just report
                // that the pointer does not resolve to an element
                CHECK(!j.contains(jp));
                CHECK(!j_const.contains(jp));
            }
            {
                // #5395: same as above, but using the exact reproduction from the issue
                json::json_pointer const jp("/99999999999999999999");
                std::string const throw_msg = "[json.exception.out_of_range.404] unresolved reference token '99999999999999999999'";
                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j.at(jp) = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const.at(jp) == 1, throw_msg.c_str(), json::out_of_range&);
                CHECK(!j.contains(jp));
                CHECK(!j_const.contains(jp));
            }
            {
                // #5395: a reference token that is numerically representable in
                // unsigned long long but exceeds size_type's max (e.g. ULLONG_MAX
                // itself on typical 64-bit platforms, where size_type's max equals
                // ULLONG_MAX) must not make contains() throw either
                json::json_pointer const jp("/18446744073709551615");
                std::string const throw_msg = "[json.exception.out_of_range.410] array index 18446744073709551615 exceeds size_type";
                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j.at(jp) = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const.at(jp) == 1, throw_msg.c_str(), json::out_of_range&);
                CHECK(!j.contains(jp));
                CHECK(!j_const.contains(jp));
            }
            // on some machines, the check below is not constant
@@ -334,6 +372,10 @@ TEST_CASE("JSON pointers")
                CHECK_THROWS_WITH_AS(j[jp] = 1, throw_msg.c_str(), json::out_of_range&);
                CHECK_THROWS_WITH_AS(j_const[jp] == 1, throw_msg.c_str(), json::out_of_range&);
                // #5395: contains() must not throw for a reference token exceeding size_type's max
                CHECK(!j.contains(jp));
                CHECK(!j_const.contains(jp));
            }
            DOCTEST_MSVC_SUPPRESS_WARNING_POP
@@ -1598,6 +1598,67 @@ TEST_CASE("MessagePack")
 }
 // use this testcase outside [hide] to run it with Valgrind
 TEST_CASE("MessagePack nesting does not consume the call stack")
 {
    // Reading a container used to call back into the value reader once per
    // element, so the native call stack grew with the nesting depth of the
    // input: one frame per byte for repeated 0x91 (a one-element array), which
    // crashes the process long before the input is exhausted (#5104). The
    // containers are kept on a heap stack now.
    //
    // Note that deeply nested values must not be compared, copied or dumped
    // here: those operations are still recursive, and would reintroduce the
    // very crash this checks for. Depth is measured by descending instead.
    SECTION("an unterminated chain is reported, not crashed on")
    {
        json _;
        const std::vector<uint8_t> input(300000, 0x91);
        CHECK_THROWS_WITH_AS(_ = json::from_msgpack(input), "[json.exception.parse_error.110] parse error at byte 300001: syntax error while parsing MessagePack value: unexpected end of input", json::parse_error&);
        CHECK(json::from_msgpack(input, true, false).is_discarded());
    }
    SECTION("a well-formed deep value is read through the SAX interface")
    {
        std::vector<uint8_t> input(300000, 0x91);
        input.push_back(0x01); // innermost value
        SaxCountdown accept_all(600001);
        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::msgpack));
    }
    SECTION("a well-formed deep value is read into a value")
    {
        const std::size_t depth = 10000;
        std::vector<uint8_t> input(depth, 0x91);
        input.push_back(0x01);
        json j = json::from_msgpack(input);
        std::size_t measured = 0;
        const json* p = &j;
        while (p->is_array() && !p->empty())
        {
            p = &p->front();
            ++measured;
        }
        CHECK(measured == depth);
        CHECK(p->is_number());
    }
    SECTION("containers are still read the same way")
    {
        CHECK(json::from_msgpack(std::vector<uint8_t>({0x90})) == json::array());
        CHECK(json::from_msgpack(std::vector<uint8_t>({0x80})) == json::object());
        CHECK(json::from_msgpack(std::vector<uint8_t>({0x92, 0x90, 0x80})) == json({json::array(), json::object()}));
        CHECK(json::from_msgpack(std::vector<uint8_t>({0x91, 0x91, 0x91, 0x90})) == json({{{json::array()}}}));
        CHECK(json::from_msgpack(std::vector<uint8_t>({0x81, 0xA1, 'a', 0x81, 0xA1, 'b', 0x92, 0x01, 0x02})) == json({{"a", {{"b", {1, 2}}}}}));
        // array 16 and map 32, i.e. the counted forms
        CHECK(json::from_msgpack(std::vector<uint8_t>({0xDC, 0x00, 0x02, 0x01, 0x02})) == json({1, 2}));
        CHECK(json::from_msgpack(std::vector<uint8_t>({0xDF, 0x00, 0x00, 0x00, 0x01, 0xA1, 'k', 0xC3})) == json({{"k", true}}));
    }
 }
 TEST_CASE("single MessagePack roundtrip")
 {
    SECTION("sample.json")
@@ -0,0 +1,34 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 // This file makes sure that none of the internal JSON_HEDLEY_* macros (vendored
 // from https://nemequ.github.io/hedley/, see
 // include/nlohmann/thirdparty/hedley/hedley.hpp) leak into the including
 // translation unit. include/nlohmann/detail/macro_unscope.hpp is supposed to
 // #undef every JSON_HEDLEY_* macro (via hedley_undef.hpp) once json.hpp has
 // been fully processed. See https://github.com/nlohmann/json/issues/5408,
 // where JSON_HEDLEY_PRAGMA, JSON_HEDLEY_PREDICT_TRUE, JSON_HEDLEY_PREDICT_FALSE,
 // and JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE escaped this cleanup because
 // hedley_undef.hpp had no matching #undef for them.
 //
 // hedley_undef_checks.inc (included below) is generated at CMake configure/
 // build time by cmake/scripts/gen_hedley_undef_check.cmake, which derives the
 // full list of JSON_HEDLEY_* macro names directly from hedley.hpp. That way
 // this test covers every macro Hedley actually defines -- not a hardcoded
 // snapshot that would silently go stale the next time `make update_hedley`
 // runs -- and can never drift from the vendored header.
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 TEST_CASE("JSON_HEDLEY macros do not leak after including json.hpp")
 {
 #include "hedley_undef_checks.inc"
    CHECK(true); // keep an assertion when nothing leaked
 }
@@ -29,10 +29,7 @@ using nlohmann::json;
 #include <limits>
 #include <cstdio>
 #include "make_test_data_available.hpp"
-
+#include "test_utils.hpp"
 #ifdef JSON_HAS_CPP_17
    #include <variant>
 #endif
 #include "fifo_map.hpp"
@@ -1373,7 +1370,8 @@ TEST_CASE("regression tests 1")
        std::array<uint8_t, 28> key1 = {{ 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127, 0 }};
        std::string const key1_str(reinterpret_cast<char*>(key1.data()));
        json const j = key1_str;
-        CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E", json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E", json::type_error&);
    }
 #if JSON_USE_IMPLICIT_CONVERSIONS
@@ -31,6 +31,8 @@ using ordered_json = nlohmann::ordered_json;
 #include <type_traits>
 #include <utility>
 #include "test_utils.hpp"
 #ifdef JSON_HAS_CPP_17
    #include <any>
    #include <variant>
@@ -239,209 +241,6 @@ class my_allocator : public std::allocator<T>
    };
 };
 /////////////////////////////////////////////////////////////////////
 // for #3077
 /////////////////////////////////////////////////////////////////////
 class FooAlloc
 {};
 class Foo
 {
  public:
    explicit Foo(const FooAlloc& /* unused */ = FooAlloc()) {}
    bool value = false;
 };
 class FooBar
 {
  public:
    Foo foo{}; // NOLINT(readability-redundant-member-init)
 };
 inline void from_json(const nlohmann::json& j, FooBar& fb) // NOLINT(misc-use-internal-linkage)
 {
    j.at("value").get_to(fb.foo.value);
 }
 /////////////////////////////////////////////////////////////////////
 // for #3171
 /////////////////////////////////////////////////////////////////////
 struct for_3171_base // NOLINT(cppcoreguidelines-special-member-functions)
 {
    for_3171_base(const std::string& /*unused*/ = {}) {}
    virtual ~for_3171_base();
    for_3171_base(const for_3171_base& other) // NOLINT(hicpp-use-equals-default,modernize-use-equals-default)
        : str(other.str)
    {}
    for_3171_base& operator=(const for_3171_base& other)
    {
        if (this != &other)
        {
            str = other.str;
        }
        return *this;
    }
    for_3171_base(for_3171_base&& other) noexcept
        : str(std::move(other.str))
    {}
    for_3171_base& operator=(for_3171_base&& other) noexcept
    {
        if (this != &other)
        {
            str = std::move(other.str);
        }
        return *this;
    }
    virtual void _from_json(const json& j)
    {
        j.at("str").get_to(str);
    }
    std::string str{}; // NOLINT(readability-redundant-member-init)
 };
 for_3171_base::~for_3171_base() = default;
 struct for_3171_derived : public for_3171_base
 {
    for_3171_derived() = default;
    ~for_3171_derived() override;
    explicit for_3171_derived(const std::string& /*unused*/) { }
    for_3171_derived(const for_3171_derived& other) // NOLINT(hicpp-use-equals-default,modernize-use-equals-default)
        : for_3171_base(other)
    {}
    for_3171_derived& operator=(const for_3171_derived& other)
    {
        if (this != &other)
        {
            for_3171_base::operator=(other); // Call base class assignment operator
        }
        return *this;
    }
    for_3171_derived(for_3171_derived&& other) noexcept
        : for_3171_base(std::move(other))
    {}
    for_3171_derived& operator=(for_3171_derived&& other) noexcept
    {
        if (this != &other)
        {
            for_3171_base::operator=(std::move(other)); // Call base class move assignment operator
        }
        return *this;
    }
 };
 for_3171_derived::~for_3171_derived() = default;
 inline void from_json(const json& j, for_3171_base& tb) // NOLINT(misc-use-internal-linkage)
 {
    tb._from_json(j);
 }
 /////////////////////////////////////////////////////////////////////
 // for #3312
 /////////////////////////////////////////////////////////////////////
 #ifdef JSON_HAS_CPP_20
 struct for_3312
 {
    std::string name;
 };
 inline void from_json(const json& j, for_3312& obj) // NOLINT(misc-use-internal-linkage)
 {
    j.at("name").get_to(obj.name);
 }
 #endif
 /////////////////////////////////////////////////////////////////////
 // for #3204
 /////////////////////////////////////////////////////////////////////
 struct for_3204_foo
 {
    for_3204_foo() = default;
    explicit for_3204_foo(std::string /*unused*/) {} // NOLINT(performance-unnecessary-value-param)
 };
 struct for_3204_bar
 {
    enum constructed_from_t // NOLINT(cppcoreguidelines-use-enum-class)
    {
        constructed_from_none = 0,
        constructed_from_foo = 1,
        constructed_from_json = 2
    };
    explicit for_3204_bar(std::function<void(for_3204_foo)> /*unused*/) noexcept // NOLINT(performance-unnecessary-value-param)
        : constructed_from(constructed_from_foo) {}
    explicit for_3204_bar(std::function<void(json)> /*unused*/) noexcept // NOLINT(performance-unnecessary-value-param)
        : constructed_from(constructed_from_json) {}
    constructed_from_t constructed_from = constructed_from_none;
 };
 /////////////////////////////////////////////////////////////////////
 // for #3333
 /////////////////////////////////////////////////////////////////////
 struct for_3333 final
 {
    for_3333(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}
    template <class T>
    for_3333(const T& /*unused*/)
    {
        CHECK(false);
    }
    int x = 0;
    int y = 0;
 };
 template <>
 inline for_3333::for_3333(const json& j)
    : for_3333(j.value("x", 0), j.value("y", 0))
 {}
 /////////////////////////////////////////////////////////////////////
 // for #3810
 /////////////////////////////////////////////////////////////////////
 struct Example_3810
 {
    int bla{};
    Example_3810() = default;
 };
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Example_3810, bla) // NOLINT(misc-use-internal-linkage)
 /////////////////////////////////////////////////////////////////////
 // for #4740
 /////////////////////////////////////////////////////////////////////
 #ifdef JSON_HAS_CPP_17
 struct Example_4740
 {
    std::optional<std::string> host = std::nullopt;
    std::optional<int> port = std::nullopt;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Example_4740, host, port)
 };
 #endif
 TEST_CASE("regression tests 2")
 {
    SECTION("issue #1001 - Fix memory leak during parser callback")
@@ -639,7 +438,8 @@ TEST_CASE("regression tests 2")
                s += static_cast<char>(i);
            }
            dump_test["1"] = s;
-            dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+            // dump() is nodiscard; this only checks that dumping does not throw/crash
            utils::ignore_return_value(dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace));
        }
    }
@@ -731,12 +531,14 @@ TEST_CASE("regression tests 2")
    {
        const std::array<unsigned char, 23> data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}};
        const json j = json::from_msgpack(data.data(), data.size());
        // dump() is nodiscard; this only checks that dumping does not throw
        CHECK_NOTHROW(
-            j.dump(4,                             // Indent
+            utils::ignore_return_value(
-                   ' ',                           // Indent char
+                j.dump(4,                             // Indent
-                   false,                         // Ensure ascii
+                       ' ',                           // Indent char
-                   json::error_handler_t::strict  // Error
+                       false,                         // Ensure ascii
-                  ));
+                       json::error_handler_t::strict  // Error
                      )));
    }
    SECTION("PR #2181 - regression bug with lvalue")
@@ -959,611 +761,6 @@ TEST_CASE("regression tests 2")
        CHECK(j == k);
    }
 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
    // JSON_HAS_CPP_17 (do not remove; see note at top of file)
    SECTION("issue #3070 - Version 3.10.3 breaks backward-compatibility with 3.10.2 ")
    {
        nlohmann::detail::std_fs::path text_path("/tmp/text.txt");
        const json j(text_path);
        const auto j_path = j.get<nlohmann::detail::std_fs::path>();
        CHECK(j_path == text_path);
 #if DOCTEST_CLANG || DOCTEST_GCC >= DOCTEST_COMPILER(8, 4, 0)
        // only known to work on Clang and GCC >=8.4
        CHECK_THROWS_WITH_AS(nlohmann::detail::std_fs::path(json(1)), "[json.exception.type_error.302] type must be string, but is number", json::type_error);
 #endif
    }
 #endif
    SECTION("issue #3077 - explicit constructor with default does not compile")
    {
        json j;
        j[0]["value"] = true;
        std::vector<FooBar> foo;
        j.get_to(foo);
    }
    SECTION("issue #3108 - ordered_json doesn't support range based erase")
    {
        ordered_json j = {1, 2, 2, 4};
        auto last = std::unique(j.begin(), j.end());
        j.erase(last, j.end());
        CHECK(j.dump() == "[1,2,4]");
        j.erase(std::remove_if(j.begin(), j.end(), [](const ordered_json & val)
        {
            return val == 2;
        }), j.end());
        CHECK(j.dump() == "[1,4]");
    }
    SECTION("issue #3343 - json and ordered_json are not interchangeable")
    {
        json::object_t jobj({ { "product", "one" } });
        ordered_json::object_t ojobj({{"product", "one"}});
        auto jit = jobj.begin();
        auto ojit = ojobj.begin();
        CHECK(jit->first == ojit->first);
        CHECK(jit->second.get<std::string>() == ojit->second.get<std::string>());
    }
    SECTION("issue #3171 - if class is_constructible from std::string wrong from_json overload is being selected, compilation failed")
    {
        const json j{{ "str", "value"}};
        // failed with: error: no match for ‘operator=’ (operand types are ‘for_3171_derived’ and ‘const nlohmann::basic_json<>::string_t’
        //                                               {aka ‘const std::__cxx11::basic_string<char>’})
        //                  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
        auto td = j.get<for_3171_derived>();
        CHECK(td.str == "value");
    }
 #ifdef JSON_HAS_CPP_20
    SECTION("issue #3312 - Parse to custom class from unordered_json breaks on G++11.2.0 with C++20")
    {
        // see test for #3171
        const ordered_json j = {{"name", "class"}};
        for_3312 obj{};
        j.get_to(obj);
        CHECK(obj.name == "class");
    }
 #endif
 #if defined(JSON_HAS_CPP_17) && JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("issue #3428 - Error occurred when converting nlohmann::json to std::any")
    {
        const json j;
        const std::any a1 = j;
        std::any&& a2 = j;
        CHECK(a1.type() == typeid(j));
        CHECK(a2.type() == typeid(j));
    }
 #endif
    SECTION("issue #3204 - ambiguous regression")
    {
        const for_3204_bar bar_from_foo([](for_3204_foo) noexcept {}); // NOLINT(performance-unnecessary-value-param)
        const for_3204_bar bar_from_json([](json) noexcept {}); // NOLINT(performance-unnecessary-value-param)
        CHECK(bar_from_foo.constructed_from == for_3204_bar::constructed_from_foo);
        CHECK(bar_from_json.constructed_from == for_3204_bar::constructed_from_json);
    }
    SECTION("issue #3333 - Ambiguous conversion from nlohmann::basic_json<> to custom class")
    {
        const json j
        {
            {"x", 1},
            {"y", 2}
        };
        const for_3333 p = j;
        CHECK(p.x == 1);
        CHECK(p.y == 2);
    }
    SECTION("issue #3810 - ordered_json doesn't support construction from C array of custom type")
    {
        Example_3810 states[45]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
        // fix "not used" warning
        states[0].bla = 1;
        const auto* const expected = R"([{"bla":1},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0}])";
        // This works:
        nlohmann::json j;
        j["test"] = states;
        CHECK(j["test"].dump() == expected);
        // This doesn't compile:
        nlohmann::ordered_json oj;
        oj["test"] = states;
        CHECK(oj["test"].dump() == expected);
    }
 #ifdef JSON_HAS_CPP_17
    SECTION("issue #4740 - build issue with std::optional")
    {
        const auto t1 = Example_4740();
        const auto j1 = nlohmann::json(t1);
        CHECK(j1.dump() == "{\"host\":null,\"port\":null}");
        const auto t2 = j1.get<Example_4740>();
        CHECK(!t2.host.has_value());
        CHECK(!t2.port.has_value());
        // improve coverage
        auto t3 = Example_4740();
        t3.port = 80;
        t3.host = "example.com";
        const auto j2 = nlohmann::json(t3);
        CHECK(j2.dump() == "{\"host\":\"example.com\",\"port\":80}");
        const auto t4 = j2.get<Example_4740>();
        CHECK(t4.host.has_value());
        CHECK(t4.port.has_value());
    }
 #endif
 #if !defined(_MSVC_LANG)
    // MSVC returns garbage on invalid enum values, so this test is excluded
    // there.
    SECTION("issue #4762 - json exception 302 with unhelpful explanation : type must be number, but is number")
    {
        // In #4762, the main issue was that a json object with an invalid type
        // returned "number" as type_name(), because this was the default case.
        // This test makes sure we now return "invalid" instead.
        json j;
        j.m_data.m_type = static_cast<json::value_t>(100); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
        CHECK(j.type_name() == "invalid");
    }
 #endif
 #ifdef JSON_HAS_CPP_17
    SECTION("issue #4804: from_cbor incompatible with std::vector<std::byte> as binary_t")
    {
        const std::vector<std::uint8_t> data = {0x80};
        const auto decoded = json_4804::from_cbor(data);
        CHECK((decoded == json_4804::array()));
    }
    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
    {
        // Test that assigning a custom BinaryType directly creates a binary value, not an array
        const std::vector<std::byte> original{std::byte{1}, std::byte{2}, std::byte{3}};
        const json_4804 j = original;
        CHECK(j.is_binary());
        CHECK(!j.is_array());
        // Test round-tripping: extracting the binary value back as the custom container type
        const auto extracted = j.get<std::vector<std::byte>>();
        CHECK(extracted == original);
        // Test that the default json alias behavior is unchanged: std::vector<uint8_t> -> array
        const json default_json = std::vector<std::uint8_t> {1, 2, 3};
        CHECK(default_json.is_array());
        CHECK(!default_json.is_binary());
    }
    SECTION("discussion #4209 - custom BinaryType extraction from parsed array")
    {
        // Test that extracting a custom BinaryType from a parsed JSON array still works
        // (not just from a binary-typed node)
        const auto j = json_4804::parse("[1,2,3]");
        CHECK(j.is_array());
        CHECK(!j.is_binary());
        // Extracting as custom BinaryType should work from arrays
        const auto extracted = j.get<std::vector<std::byte>>();
        CHECK(extracted.size() == 3);
        CHECK(extracted[0] == std::byte{1});
        CHECK(extracted[1] == std::byte{2});
        CHECK(extracted[2] == std::byte{3});
    }
    SECTION("issue #5046 - implicit conversion of return json to std::optional no longer implicit")
    {
        const json jval{};
        auto GetValue = [](const json & valRoot) -> std::optional<json>
        {
            if (valRoot.contains("default"))
            {
                return valRoot.at("default");
            }
            return std::nullopt;
        };
        auto result = GetValue(jval);
        CHECK(!result.has_value());
    }
 #endif
 #if JSON_HAS_RANGES == 1
    SECTION("issue #4440 - assert when using std::views::filter and GCC 10")
    {
        auto noOpFilter = std::views::filter([](auto&&) noexcept
        {
            return true;
        });
        json j = {1, 2, 3};
        auto filtered = j | noOpFilter;
        CHECK(*filtered.begin() == 1);
    }
 #endif
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    SECTION("issue #4916 - constructing array from C++20 ranges view does not work")
    {
        std::vector<int> nums{1, 2, 37, 42, 21};
        auto filteredNums = nums | std::views::filter([](int i)
        {
            return i > 10;
        });
        json const j(filteredNums);
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({37, 42, 21}));
    }
 #endif
    // owning_view is not available in libstdc++ < 12
 #if JSON_HAS_RANGES && !defined(__MINGW32__) && !(defined(__GLIBCXX__) && _GLIBCXX_RELEASE < 12)
    SECTION("issue #4916 - constructing array from prvalue C++20 ranges view (owning_view)")
    {
        json const j(std::vector<int> {1, 2, 37, 42, 21} | std::views::filter([](int i)
        {
            return i > 10;
        }));
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({37, 42, 21}));
    }
 #endif
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    SECTION("issue #4916 - constructing array from C++20 transform view (prvalue elements)")
    {
        std::vector<int> nums{1, 2, 3};
        auto t = nums | std::views::transform([](int i) noexcept
        {
            return i * 2;
        });
        json const j(t);
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({2, 4, 6}));
    }
 #endif
 }
 TEST_CASE_TEMPLATE("issue #4798 - nlohmann::json::to_msgpack() encode float NaN as double", T, double, float) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
 {
    // With issue #4798, we encode NaN, infinity, and -infinity as float instead
    // of double to allow for smaller encodings.
    const json jx = std::numeric_limits<T>::quiet_NaN();
    const json jy = std::numeric_limits<T>::infinity();
    const json jz = -std::numeric_limits<T>::infinity();
    /////////////////////////////////////////////////////////////////////////
    // MessagePack
    /////////////////////////////////////////////////////////////////////////
    // expected MessagePack values
    const std::vector<std::uint8_t> msgpack_x = {{0xCA, 0x7F, 0xC0, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_y = {{0xCA, 0x7F, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_z = {{0xCA, 0xFF, 0x80, 0x00, 0x00}};
    CHECK(json::to_msgpack(jx) == msgpack_x);
    CHECK(json::to_msgpack(jy) == msgpack_y);
    CHECK(json::to_msgpack(jz) == msgpack_z);
    CHECK(std::isnan(json::from_msgpack(msgpack_x).get<T>()));
    CHECK(json::from_msgpack(msgpack_y).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_msgpack(msgpack_z).get<T>() == -std::numeric_limits<T>::infinity());
    // Make sure the other MessagePakc encodings for NaN, infinity, and
    // -infinity are still supported.
    const std::vector<std::uint8_t> msgpack_x_2 = {{0xCB, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_y_2 = {{0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_z_2 = {{0xCB, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    CHECK(std::isnan(json::from_msgpack(msgpack_x_2).get<T>()));
    CHECK(json::from_msgpack(msgpack_y_2).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_msgpack(msgpack_z_2).get<T>() == -std::numeric_limits<T>::infinity());
    /////////////////////////////////////////////////////////////////////////
    // CBOR
    /////////////////////////////////////////////////////////////////////////
    // expected CBOR values
    const std::vector<std::uint8_t> cbor_x = {{0xF9, 0x7E, 0x00}};
    const std::vector<std::uint8_t> cbor_y = {{0xF9, 0x7C, 0x00}};
    const std::vector<std::uint8_t> cbor_z = {{0xF9, 0xfC, 0x00}};
    CHECK(json::to_cbor(jx) == cbor_x);
    CHECK(json::to_cbor(jy) == cbor_y);
    CHECK(json::to_cbor(jz) == cbor_z);
    CHECK(std::isnan(json::from_cbor(cbor_x).get<T>()));
    CHECK(json::from_cbor(cbor_y).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z).get<T>() == -std::numeric_limits<T>::infinity());
    // Make sure the other CBOR encodings for NaN, infinity, and -infinity are
    // still supported.
    const std::vector<std::uint8_t> cbor_x_2 = {{0xFA, 0x7F, 0xC0, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_y_2 = {{0xFA, 0x7F, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_z_2 = {{0xFA, 0xFF, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_x_3 = {{0xFB, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_y_3 = {{0xFB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_z_3 = {{0xFB, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    CHECK(std::isnan(json::from_cbor(cbor_x_2).get<T>()));
    CHECK(json::from_cbor(cbor_y_2).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z_2).get<T>() == -std::numeric_limits<T>::infinity());
    CHECK(std::isnan(json::from_cbor(cbor_x_3).get<T>()));
    CHECK(json::from_cbor(cbor_y_3).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z_3).get<T>() == -std::numeric_limits<T>::infinity());
 }
 TEST_CASE("regression test #5074 - portable workaround for single-element brace init")
 {
    json const j_obj = {{"key", "value"}};
    json const j = json::array({j_obj});
    CHECK(j.is_array());
    CHECK(j.size() == 1);
    CHECK(j[0] == j_obj);
 }
 #if defined(JSON_BRACE_INIT_COPY_SEMANTICS) && (JSON_BRACE_INIT_COPY_SEMANTICS == 1)
 TEST_CASE("regression test #5074 - single-element brace init with JSON_BRACE_INIT_COPY_SEMANTICS")
 {
    // with JSON_BRACE_INIT_COPY_SEMANTICS: single-element brace init copies/moves
    json const j_obj = {{"key", "value"}, {"num", 42}};
    json const j_arr = {1, 2, 3};
    // object: brace init copies instead of wrapping
    json const j1{j_obj};
    CHECK(j1.is_object());
    CHECK(j1 == j_obj);
    // array: brace init copies instead of wrapping
    json const j2{j_arr};
    CHECK(j2.is_array());
    CHECK(j2.size() == 3);
    CHECK(j2 == j_arr);
    // primitives still work as initializer lists
    json const j3{true};
    CHECK(j3.is_boolean());
    json const j4{42};
    CHECK(j4.is_number_integer());
 }
 #endif
 struct Example_5122
 {
    float b = 2;
    nlohmann::ordered_map<std::string, std::string> c{}; // NOLINT(readability-redundant-member-init): needed for GCC -Weffc++
    int a = 1;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Example_5122, b, c, a)
 };
 TEST_CASE("regression test #5122 - from_json into types holding nlohmann::ordered_map")
 {
    Example_5122 src;
    src.c.emplace("first", "1");
    src.c.emplace("second", "2");
    ordered_json const j = src;
    Example_5122 const dst = j.get<Example_5122>();
    CHECK(dst.b == src.b);
    CHECK(dst.a == src.a);
    REQUIRE(dst.c.size() == src.c.size());
    auto src_it = src.c.begin();
    auto dst_it = dst.c.begin();
    for (; src_it != src.c.end(); ++src_it, ++dst_it)
    {
        CHECK(dst_it->first == src_it->first);
        CHECK(dst_it->second == src_it->second);
    }
 }
 // -Wself-assign-overloaded was introduced in Clang 7. Gate the pragma on
 // __has_warning so older Clang versions do not error with "unknown warning
 // group". The __has_warning check has to stay inside the __clang__ branch
 // because GCC does not provide it and would tokenize-error on the argument.
 #if defined(__clang__) && defined(__has_warning)
    #if __has_warning("-Wself-assign-overloaded")
        DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
        DOCTEST_CLANG_SUPPRESS_WARNING("-Wself-assign-overloaded")
    #endif
 #endif
 TEST_CASE("regression test #5122 - nlohmann::ordered_map copy-assignment is self-assignment safe")
 {
    nlohmann::ordered_map<std::string, std::string> m;
    m.emplace("first", "1");
    m.emplace("second", "2");
    // Insertion order is preserved by ordered_map, so we can check it directly.
    m = m;
    REQUIRE(m.size() == 2);
    auto it = m.begin();
    CHECK(it->first == "first");
    CHECK(it->second == "1");
    ++it;
    CHECK(it->first == "second");
    CHECK(it->second == "2");
 }
 #if defined(__clang__) && defined(__has_warning)
    #if __has_warning("-Wself-assign-overloaded")
        DOCTEST_CLANG_SUPPRESS_WARNING_POP
    #endif
 #endif
 TEST_CASE("regression test #5122 - nlohmann::ordered_map move-assignment transfers contents")
 {
    nlohmann::ordered_map<std::string, std::string> src;
    src.emplace("first", "1");
    src.emplace("second", "2");
    nlohmann::ordered_map<std::string, std::string> dst;
    dst.emplace("stale", "x");
    dst = std::move(src);
    REQUIRE(dst.size() == 2);
    auto it = dst.begin();
    CHECK(it->first == "first");
    CHECK(it->second == "1");
    ++it;
    CHECK(it->first == "second");
    CHECK(it->second == "2");
    // Re-assigning into the moved-from object must leave it in a usable state.
    src = nlohmann::ordered_map<std::string, std::string> {};
    src.emplace("after-move", "3");
    REQUIRE(src.size() == 1);
    CHECK(src.begin()->first == "after-move");
 }
 // Stand-in for a third-party library (e.g., Eigen as of 3.4, which added
 // STL-compatible begin()/end() to its vector types), living in its own
 // namespace with its own to_json overload for its vector type.
 namespace issue_4320_eigen
 {
 // "array-compatible" from the library's point of view (it has begin()/end()),
 // but for which this (fake) third-party namespace provides its own to_json.
 struct vector3
 {
    double v[3]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-use-default-member-init,modernize-use-default-member-init)
    vector3(double x, double y, double z) : v{x, y, z} {} // NOLINT(hicpp-member-init,cppcoreguidelines-pro-type-member-init)
    double x() const
    {
        return v[0];
    }
    double y() const
    {
        return v[1];
    }
    double z() const
    {
        return v[2];
    }
    double* begin()
    {
        return v;
    }
    double* end()
    {
        return v + 3;
    }
    const double* begin() const
    {
        return v;
    }
    const double* end() const
    {
        return v + 3;
    }
 };
 inline void to_json(json& j, const vector3& v) // NOLINT(misc-use-internal-linkage)
 {
    j = {{"x", v.x()}, {"y", v.y()}, {"z", v.z()}};
 }
 } // namespace issue_4320_eigen
 // The user's own namespace, using the (fake) Eigen type as an implementation
 // detail behind a payload type that has nothing to do with vectors/arrays.
 namespace issue_4320
 {
 // Publicly derives from issue_4320_eigen::vector3 but does *not* define its
 // own to_json - it is only ever used as a temporary to reach the base
 // class's to_json via ADL.
 struct vector3_wrapper : issue_4320_eigen::vector3
 {
    using issue_4320_eigen::vector3::vector3;
 };
 struct payload
 {
    double x, y, z;
 };
 inline vector3_wrapper to_eigen(const payload& p) // NOLINT(misc-use-internal-linkage)
 {
    return {p.x, p.y, p.z};
 }
 inline void to_json(json& j, const payload& p) // NOLINT(misc-use-internal-linkage)
 {
    // Unqualified call, passing a *derived* vector3_wrapper: relies on ADL
    // finding issue_4320_eigen::to_json(json&, const vector3&) through the
    // vector3 base class, via a derived-to-base conversion. Must NOT resolve
    // to the library's own generic array-compatible to_json (an exact-match
    // template for vector3_wrapper, since it also has begin()/end()), which
    // would serialize this as [x, y, z] instead of {"x":x, "y":y, "z":z}.
    to_json(j, to_eigen(p));
 }
 } // namespace issue_4320
 TEST_CASE("issue #4320 - custom base class must not leak nlohmann::detail into ADL")
 {
    // Before the fix, basic_json unconditionally derived from a type living in
    // nlohmann::detail (json_default_base), which made nlohmann::detail an
    // associated namespace of every basic_json for ADL purposes. That leaked
    // the library's internal generic-array to_json overload into unqualified
    // to_json() calls made from user code, silently bypassing user-defined
    // to_json overloads reached via a derived-to-base conversion.
    const issue_4320::payload p{1.0, 2.0, 3.0};
    json j;
    to_json(j, p);
    CHECK(j == json({{"x", 1.0}, {"y", 2.0}, {"z", 3.0}}));
 }
 TEST_CASE("issue #5338 - truncated CBOR tagged binary subtype is rejected")
 {
    const std::vector<std::vector<std::uint8_t>> truncated_tags =
    {
        {0xD8},
        {0xD9, 0x00},
        {0xDA, 0x00, 0x00, 0x00},
        {0xDB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
    };
    for (const auto& data : truncated_tags)
    {
        CAPTURE(data);
        for (const auto tag_handler :
                {
                    json::cbor_tag_handler_t::ignore, json::cbor_tag_handler_t::store
                })
        {
            CAPTURE(tag_handler);
            const auto result = json::from_cbor(data, true, false, tag_handler);
            CHECK(result.is_discarded());
        }
    }
 }
 TEST_CASE("issue #5402 - update(merge_objects=true) overwrites a primitive with an object")
 {
    json t = {{"k", 1}};
    t.update(json{{"k", {{"x", 2}}}}, true);
    CHECK(t == json({{"k", {{"x", 2}}}}));
    json mixed = {{"keep", {{"a", 1}}}, {"replace", 1}};
    mixed.update(json{{"keep", {{"b", 2}}}, {"replace", {{"x", 2}}}}, true);
    CHECK(mixed == json({{"keep", {{"a", 1}, {"b", 2}}}, {"replace", {{"x", 2}}}}));
 }
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -0,0 +1,899 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  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
 // cmake/test.cmake selects the C++ standard versions with which to build a
 // unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
 // When using macros that are only defined for particular versions of the standard
 // (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
 // version macro in a comment close by, like this:
 // JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
 #include "doctest_compatibility.h"
 // for some reason including this after the json header leads to linker errors with VS 2017...
 #include <locale>
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 using ordered_json = nlohmann::ordered_json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif
 #include <cstdio>
 #include <list>
 #include <type_traits>
 #include <utility>
 #ifdef JSON_HAS_CPP_17
    #include <any>
    #include <variant>
 #endif
 #ifdef JSON_HAS_CPP_17
    #if __has_include(<optional>)
        #include <optional>
    #elif __has_include(<experimental/optional>)
    #endif
    /////////////////////////////////////////////////////////////////////
    // for #4804
    /////////////////////////////////////////////////////////////////////
    using json_4804 = nlohmann::basic_json<std::map,        // ObjectType
    std::vector,     // ArrayType
    std::string,     // StringType
    bool,            // BooleanType
    std::int64_t,    // NumberIntegerType
    std::uint64_t,   // NumberUnsignedType
    double,          // NumberFloatType
    std::allocator,  // AllocatorType
    nlohmann::adl_serializer,  // JSONSerializer
    std::vector<std::byte>,    // BinaryType
    void                       // CustomBaseClass
    >;
 #endif
 #ifdef JSON_HAS_CPP_20
    #if __has_include(<span>)
        #include <span>
    #endif
 #endif
 /////////////////////////////////////////////////////////////////////
 // for #4825 - explicitly instantiating basic_json must compile; this
 // forces instantiation of binary_writer::write_bjdata_ndarray, whose
 // static_cast<string_t> was ambiguous under explicit instantiation on
 // C++17. Merely compiling this translation unit is the regression test.
 /////////////////////////////////////////////////////////////////////
 template class nlohmann::basic_json<>;
 /////////////////////////////////////////////////////////////////////
 // for #4440
 /////////////////////////////////////////////////////////////////////
 #if JSON_HAS_RANGES == 1
    #include <ranges>
 #endif
 // NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
 /////////////////////////////////////////////////////////////////////
 // for #3077
 /////////////////////////////////////////////////////////////////////
 class FooAlloc
 {};
 class Foo
 {
  public:
    explicit Foo(const FooAlloc& /* unused */ = FooAlloc()) {}
    bool value = false;
 };
 class FooBar
 {
  public:
    Foo foo{}; // NOLINT(readability-redundant-member-init)
 };
 inline void from_json(const nlohmann::json& j, FooBar& fb) // NOLINT(misc-use-internal-linkage)
 {
    j.at("value").get_to(fb.foo.value);
 }
 /////////////////////////////////////////////////////////////////////
 // for #3171
 /////////////////////////////////////////////////////////////////////
 struct for_3171_base // NOLINT(cppcoreguidelines-special-member-functions)
 {
    for_3171_base(const std::string& /*unused*/ = {}) {}
    virtual ~for_3171_base();
    for_3171_base(const for_3171_base& other) // NOLINT(hicpp-use-equals-default,modernize-use-equals-default)
        : str(other.str)
    {}
    for_3171_base& operator=(const for_3171_base& other)
    {
        if (this != &other)
        {
            str = other.str;
        }
        return *this;
    }
    for_3171_base(for_3171_base&& other) noexcept
        : str(std::move(other.str))
    {}
    for_3171_base& operator=(for_3171_base&& other) noexcept
    {
        if (this != &other)
        {
            str = std::move(other.str);
        }
        return *this;
    }
    virtual void _from_json(const json& j)
    {
        j.at("str").get_to(str);
    }
    std::string str{}; // NOLINT(readability-redundant-member-init)
 };
 for_3171_base::~for_3171_base() = default;
 struct for_3171_derived : public for_3171_base
 {
    for_3171_derived() = default;
    ~for_3171_derived() override;
    explicit for_3171_derived(const std::string& /*unused*/) { }
    for_3171_derived(const for_3171_derived& other) // NOLINT(hicpp-use-equals-default,modernize-use-equals-default)
        : for_3171_base(other)
    {}
    for_3171_derived& operator=(const for_3171_derived& other)
    {
        if (this != &other)
        {
            for_3171_base::operator=(other); // Call base class assignment operator
        }
        return *this;
    }
    for_3171_derived(for_3171_derived&& other) noexcept
        : for_3171_base(std::move(other))
    {}
    for_3171_derived& operator=(for_3171_derived&& other) noexcept
    {
        if (this != &other)
        {
            for_3171_base::operator=(std::move(other)); // Call base class move assignment operator
        }
        return *this;
    }
 };
 for_3171_derived::~for_3171_derived() = default;
 inline void from_json(const json& j, for_3171_base& tb) // NOLINT(misc-use-internal-linkage)
 {
    tb._from_json(j);
 }
 /////////////////////////////////////////////////////////////////////
 // for #3312
 /////////////////////////////////////////////////////////////////////
 #ifdef JSON_HAS_CPP_20
 struct for_3312
 {
    std::string name;
 };
 inline void from_json(const json& j, for_3312& obj) // NOLINT(misc-use-internal-linkage)
 {
    j.at("name").get_to(obj.name);
 }
 #endif
 /////////////////////////////////////////////////////////////////////
 // for #3204
 /////////////////////////////////////////////////////////////////////
 struct for_3204_foo
 {
    for_3204_foo() = default;
    explicit for_3204_foo(std::string /*unused*/) {} // NOLINT(performance-unnecessary-value-param)
 };
 struct for_3204_bar
 {
    enum constructed_from_t // NOLINT(cppcoreguidelines-use-enum-class)
    {
        constructed_from_none = 0,
        constructed_from_foo = 1,
        constructed_from_json = 2
    };
    explicit for_3204_bar(std::function<void(for_3204_foo)> /*unused*/) noexcept // NOLINT(performance-unnecessary-value-param)
        : constructed_from(constructed_from_foo) {}
    explicit for_3204_bar(std::function<void(json)> /*unused*/) noexcept // NOLINT(performance-unnecessary-value-param)
        : constructed_from(constructed_from_json) {}
    constructed_from_t constructed_from = constructed_from_none;
 };
 /////////////////////////////////////////////////////////////////////
 // for #3333
 /////////////////////////////////////////////////////////////////////
 struct for_3333 final
 {
    for_3333(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}
    template <class T>
    for_3333(const T& /*unused*/)
    {
        CHECK(false);
    }
    int x = 0;
    int y = 0;
 };
 template <>
 inline for_3333::for_3333(const json& j)
    : for_3333(j.value("x", 0), j.value("y", 0))
 {}
 /////////////////////////////////////////////////////////////////////
 // for #3810
 /////////////////////////////////////////////////////////////////////
 struct Example_3810
 {
    int bla{};
    Example_3810() = default;
 };
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Example_3810, bla) // NOLINT(misc-use-internal-linkage)
 /////////////////////////////////////////////////////////////////////
 // for #4740
 /////////////////////////////////////////////////////////////////////
 #ifdef JSON_HAS_CPP_17
 struct Example_4740
 {
    std::optional<std::string> host = std::nullopt;
    std::optional<int> port = std::nullopt;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Example_4740, host, port)
 };
 #endif
 TEST_CASE("regression tests 3")
 {
 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
    // JSON_HAS_CPP_17 (do not remove; see note at top of file)
    SECTION("issue #3070 - Version 3.10.3 breaks backward-compatibility with 3.10.2 ")
    {
        nlohmann::detail::std_fs::path text_path("/tmp/text.txt");
        const json j(text_path);
        const auto j_path = j.get<nlohmann::detail::std_fs::path>();
        CHECK(j_path == text_path);
 #if DOCTEST_CLANG || DOCTEST_GCC >= DOCTEST_COMPILER(8, 4, 0)
        // only known to work on Clang and GCC >=8.4
        CHECK_THROWS_WITH_AS(nlohmann::detail::std_fs::path(json(1)), "[json.exception.type_error.302] type must be string, but is number", json::type_error);
 #endif
    }
 #endif
    SECTION("issue #3077 - explicit constructor with default does not compile")
    {
        json j;
        j[0]["value"] = true;
        std::vector<FooBar> foo;
        j.get_to(foo);
    }
    SECTION("issue #3108 - ordered_json doesn't support range based erase")
    {
        ordered_json j = {1, 2, 2, 4};
        auto last = std::unique(j.begin(), j.end());
        j.erase(last, j.end());
        CHECK(j.dump() == "[1,2,4]");
        j.erase(std::remove_if(j.begin(), j.end(), [](const ordered_json & val)
        {
            return val == 2;
        }), j.end());
        CHECK(j.dump() == "[1,4]");
    }
    SECTION("issue #3343 - json and ordered_json are not interchangeable")
    {
        json::object_t jobj({ { "product", "one" } });
        ordered_json::object_t ojobj({{"product", "one"}});
        auto jit = jobj.begin();
        auto ojit = ojobj.begin();
        CHECK(jit->first == ojit->first);
        CHECK(jit->second.get<std::string>() == ojit->second.get<std::string>());
    }
    SECTION("issue #3171 - if class is_constructible from std::string wrong from_json overload is being selected, compilation failed")
    {
        const json j{{ "str", "value"}};
        // failed with: error: no match for ‘operator=’ (operand types are ‘for_3171_derived’ and ‘const nlohmann::basic_json<>::string_t’
        //                                               {aka ‘const std::__cxx11::basic_string<char>’})
        //                  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
        auto td = j.get<for_3171_derived>();
        CHECK(td.str == "value");
    }
 #ifdef JSON_HAS_CPP_20
    SECTION("issue #3312 - Parse to custom class from unordered_json breaks on G++11.2.0 with C++20")
    {
        // see test for #3171
        const ordered_json j = {{"name", "class"}};
        for_3312 obj{};
        j.get_to(obj);
        CHECK(obj.name == "class");
    }
 #endif
 #if defined(JSON_HAS_CPP_17) && JSON_USE_IMPLICIT_CONVERSIONS
    SECTION("issue #3428 - Error occurred when converting nlohmann::json to std::any")
    {
        const json j;
        const std::any a1 = j;
        std::any&& a2 = j;
        CHECK(a1.type() == typeid(j));
        CHECK(a2.type() == typeid(j));
    }
 #endif
    SECTION("issue #3204 - ambiguous regression")
    {
        const for_3204_bar bar_from_foo([](for_3204_foo) noexcept {}); // NOLINT(performance-unnecessary-value-param)
        const for_3204_bar bar_from_json([](json) noexcept {}); // NOLINT(performance-unnecessary-value-param)
        CHECK(bar_from_foo.constructed_from == for_3204_bar::constructed_from_foo);
        CHECK(bar_from_json.constructed_from == for_3204_bar::constructed_from_json);
    }
    SECTION("issue #3333 - Ambiguous conversion from nlohmann::basic_json<> to custom class")
    {
        const json j
        {
            {"x", 1},
            {"y", 2}
        };
        const for_3333 p = j;
        CHECK(p.x == 1);
        CHECK(p.y == 2);
    }
    SECTION("issue #3810 - ordered_json doesn't support construction from C array of custom type")
    {
        Example_3810 states[45]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
        // fix "not used" warning
        states[0].bla = 1;
        const auto* const expected = R"([{"bla":1},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0},{"bla":0}])";
        // This works:
        nlohmann::json j;
        j["test"] = states;
        CHECK(j["test"].dump() == expected);
        // This doesn't compile:
        nlohmann::ordered_json oj;
        oj["test"] = states;
        CHECK(oj["test"].dump() == expected);
    }
 #ifdef JSON_HAS_CPP_17
    SECTION("issue #4740 - build issue with std::optional")
    {
        const auto t1 = Example_4740();
        const auto j1 = nlohmann::json(t1);
        CHECK(j1.dump() == "{\"host\":null,\"port\":null}");
        const auto t2 = j1.get<Example_4740>();
        CHECK(!t2.host.has_value());
        CHECK(!t2.port.has_value());
        // improve coverage
        auto t3 = Example_4740();
        t3.port = 80;
        t3.host = "example.com";
        const auto j2 = nlohmann::json(t3);
        CHECK(j2.dump() == "{\"host\":\"example.com\",\"port\":80}");
        const auto t4 = j2.get<Example_4740>();
        CHECK(t4.host.has_value());
        CHECK(t4.port.has_value());
    }
 #endif
 #if !defined(_MSVC_LANG)
    // MSVC returns garbage on invalid enum values, so this test is excluded
    // there.
    SECTION("issue #4762 - json exception 302 with unhelpful explanation : type must be number, but is number")
    {
        // In #4762, the main issue was that a json object with an invalid type
        // returned "number" as type_name(), because this was the default case.
        // This test makes sure we now return "invalid" instead.
        json j;
        j.m_data.m_type = static_cast<json::value_t>(100); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
        CHECK(j.type_name() == "invalid");
    }
 #endif
 #ifdef JSON_HAS_CPP_17
    SECTION("issue #4804: from_cbor incompatible with std::vector<std::byte> as binary_t")
    {
        const std::vector<std::uint8_t> data = {0x80};
        const auto decoded = json_4804::from_cbor(data);
        CHECK((decoded == json_4804::array()));
    }
    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
    {
        // Test that assigning a custom BinaryType directly creates a binary value, not an array
        const std::vector<std::byte> original{std::byte{1}, std::byte{2}, std::byte{3}};
        const json_4804 j = original;
        CHECK(j.is_binary());
        CHECK(!j.is_array());
        // Test round-tripping: extracting the binary value back as the custom container type
        const auto extracted = j.get<std::vector<std::byte>>();
        CHECK(extracted == original);
        // Test that the default json alias behavior is unchanged: std::vector<uint8_t> -> array
        const json default_json = std::vector<std::uint8_t> {1, 2, 3};
        CHECK(default_json.is_array());
        CHECK(!default_json.is_binary());
    }
    SECTION("discussion #4209 - custom BinaryType extraction from parsed array")
    {
        // Test that extracting a custom BinaryType from a parsed JSON array still works
        // (not just from a binary-typed node)
        const auto j = json_4804::parse("[1,2,3]");
        CHECK(j.is_array());
        CHECK(!j.is_binary());
        // Extracting as custom BinaryType should work from arrays
        const auto extracted = j.get<std::vector<std::byte>>();
        CHECK(extracted.size() == 3);
        CHECK(extracted[0] == std::byte{1});
        CHECK(extracted[1] == std::byte{2});
        CHECK(extracted[2] == std::byte{3});
    }
    SECTION("issue #5046 - implicit conversion of return json to std::optional no longer implicit")
    {
        const json jval{};
        auto GetValue = [](const json & valRoot) -> std::optional<json>
        {
            if (valRoot.contains("default"))
            {
                return valRoot.at("default");
            }
            return std::nullopt;
        };
        auto result = GetValue(jval);
        CHECK(!result.has_value());
    }
 #endif
 #if JSON_HAS_RANGES == 1
    SECTION("issue #4440 - assert when using std::views::filter and GCC 10")
    {
        auto noOpFilter = std::views::filter([](auto&&) noexcept
        {
            return true;
        });
        json j = {1, 2, 3};
        auto filtered = j | noOpFilter;
        CHECK(*filtered.begin() == 1);
    }
 #endif
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    SECTION("issue #4916 - constructing array from C++20 ranges view does not work")
    {
        std::vector<int> nums{1, 2, 37, 42, 21};
        auto filteredNums = nums | std::views::filter([](int i)
        {
            return i > 10;
        });
        json const j(filteredNums);
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({37, 42, 21}));
    }
 #endif
    // owning_view is not available in libstdc++ < 12
 #if JSON_HAS_RANGES && !defined(__MINGW32__) && !(defined(__GLIBCXX__) && _GLIBCXX_RELEASE < 12)
    SECTION("issue #4916 - constructing array from prvalue C++20 ranges view (owning_view)")
    {
        json const j(std::vector<int> {1, 2, 37, 42, 21} | std::views::filter([](int i)
        {
            return i > 10;
        }));
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({37, 42, 21}));
    }
 #endif
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    SECTION("issue #4916 - constructing array from C++20 transform view (prvalue elements)")
    {
        std::vector<int> nums{1, 2, 3};
        auto t = nums | std::views::transform([](int i) noexcept
        {
            return i * 2;
        });
        json const j(t);
        CHECK(j.type() == json::value_t::array);
        CHECK(j == json({2, 4, 6}));
    }
 #endif
 }
 TEST_CASE_TEMPLATE("issue #4798 - nlohmann::json::to_msgpack() encode float NaN as double", T, double, float) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
 {
    // With issue #4798, we encode NaN, infinity, and -infinity as float instead
    // of double to allow for smaller encodings.
    const json jx = std::numeric_limits<T>::quiet_NaN();
    const json jy = std::numeric_limits<T>::infinity();
    const json jz = -std::numeric_limits<T>::infinity();
    /////////////////////////////////////////////////////////////////////////
    // MessagePack
    /////////////////////////////////////////////////////////////////////////
    // expected MessagePack values
    const std::vector<std::uint8_t> msgpack_x = {{0xCA, 0x7F, 0xC0, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_y = {{0xCA, 0x7F, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_z = {{0xCA, 0xFF, 0x80, 0x00, 0x00}};
    CHECK(json::to_msgpack(jx) == msgpack_x);
    CHECK(json::to_msgpack(jy) == msgpack_y);
    CHECK(json::to_msgpack(jz) == msgpack_z);
    CHECK(std::isnan(json::from_msgpack(msgpack_x).get<T>()));
    CHECK(json::from_msgpack(msgpack_y).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_msgpack(msgpack_z).get<T>() == -std::numeric_limits<T>::infinity());
    // Make sure the other MessagePakc encodings for NaN, infinity, and
    // -infinity are still supported.
    const std::vector<std::uint8_t> msgpack_x_2 = {{0xCB, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_y_2 = {{0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> msgpack_z_2 = {{0xCB, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    CHECK(std::isnan(json::from_msgpack(msgpack_x_2).get<T>()));
    CHECK(json::from_msgpack(msgpack_y_2).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_msgpack(msgpack_z_2).get<T>() == -std::numeric_limits<T>::infinity());
    /////////////////////////////////////////////////////////////////////////
    // CBOR
    /////////////////////////////////////////////////////////////////////////
    // expected CBOR values
    const std::vector<std::uint8_t> cbor_x = {{0xF9, 0x7E, 0x00}};
    const std::vector<std::uint8_t> cbor_y = {{0xF9, 0x7C, 0x00}};
    const std::vector<std::uint8_t> cbor_z = {{0xF9, 0xfC, 0x00}};
    CHECK(json::to_cbor(jx) == cbor_x);
    CHECK(json::to_cbor(jy) == cbor_y);
    CHECK(json::to_cbor(jz) == cbor_z);
    CHECK(std::isnan(json::from_cbor(cbor_x).get<T>()));
    CHECK(json::from_cbor(cbor_y).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z).get<T>() == -std::numeric_limits<T>::infinity());
    // Make sure the other CBOR encodings for NaN, infinity, and -infinity are
    // still supported.
    const std::vector<std::uint8_t> cbor_x_2 = {{0xFA, 0x7F, 0xC0, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_y_2 = {{0xFA, 0x7F, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_z_2 = {{0xFA, 0xFF, 0x80, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_x_3 = {{0xFB, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_y_3 = {{0xFB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    const std::vector<std::uint8_t> cbor_z_3 = {{0xFB, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
    CHECK(std::isnan(json::from_cbor(cbor_x_2).get<T>()));
    CHECK(json::from_cbor(cbor_y_2).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z_2).get<T>() == -std::numeric_limits<T>::infinity());
    CHECK(std::isnan(json::from_cbor(cbor_x_3).get<T>()));
    CHECK(json::from_cbor(cbor_y_3).get<T>() == std::numeric_limits<T>::infinity());
    CHECK(json::from_cbor(cbor_z_3).get<T>() == -std::numeric_limits<T>::infinity());
 }
 TEST_CASE("regression test #5074 - portable workaround for single-element brace init")
 {
    json const j_obj = {{"key", "value"}};
    json const j = json::array({j_obj});
    CHECK(j.is_array());
    CHECK(j.size() == 1);
    CHECK(j[0] == j_obj);
 }
 #if defined(JSON_BRACE_INIT_COPY_SEMANTICS) && (JSON_BRACE_INIT_COPY_SEMANTICS == 1)
 TEST_CASE("regression test #5074 - single-element brace init with JSON_BRACE_INIT_COPY_SEMANTICS")
 {
    // with JSON_BRACE_INIT_COPY_SEMANTICS: single-element brace init copies/moves
    json const j_obj = {{"key", "value"}, {"num", 42}};
    json const j_arr = {1, 2, 3};
    // object: brace init copies instead of wrapping
    json const j1{j_obj};
    CHECK(j1.is_object());
    CHECK(j1 == j_obj);
    // array: brace init copies instead of wrapping
    json const j2{j_arr};
    CHECK(j2.is_array());
    CHECK(j2.size() == 3);
    CHECK(j2 == j_arr);
    // primitives still work as initializer lists
    json const j3{true};
    CHECK(j3.is_boolean());
    json const j4{42};
    CHECK(j4.is_number_integer());
 }
 #endif
 struct Example_5122
 {
    float b = 2;
    nlohmann::ordered_map<std::string, std::string> c{}; // NOLINT(readability-redundant-member-init): needed for GCC -Weffc++
    int a = 1;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Example_5122, b, c, a)
 };
 TEST_CASE("regression test #5122 - from_json into types holding nlohmann::ordered_map")
 {
    Example_5122 src;
    src.c.emplace("first", "1");
    src.c.emplace("second", "2");
    ordered_json const j = src;
    Example_5122 const dst = j.get<Example_5122>();
    CHECK(dst.b == src.b);
    CHECK(dst.a == src.a);
    REQUIRE(dst.c.size() == src.c.size());
    auto src_it = src.c.begin();
    auto dst_it = dst.c.begin();
    for (; src_it != src.c.end(); ++src_it, ++dst_it)
    {
        CHECK(dst_it->first == src_it->first);
        CHECK(dst_it->second == src_it->second);
    }
 }
 // -Wself-assign-overloaded was introduced in Clang 7. Gate the pragma on
 // __has_warning so older Clang versions do not error with "unknown warning
 // group". The __has_warning check has to stay inside the __clang__ branch
 // because GCC does not provide it and would tokenize-error on the argument.
 #if defined(__clang__) && defined(__has_warning)
    #if __has_warning("-Wself-assign-overloaded")
        DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
        DOCTEST_CLANG_SUPPRESS_WARNING("-Wself-assign-overloaded")
    #endif
 #endif
 TEST_CASE("regression test #5122 - nlohmann::ordered_map copy-assignment is self-assignment safe")
 {
    nlohmann::ordered_map<std::string, std::string> m;
    m.emplace("first", "1");
    m.emplace("second", "2");
    // Insertion order is preserved by ordered_map, so we can check it directly.
    m = m;
    REQUIRE(m.size() == 2);
    auto it = m.begin();
    CHECK(it->first == "first");
    CHECK(it->second == "1");
    ++it;
    CHECK(it->first == "second");
    CHECK(it->second == "2");
 }
 #if defined(__clang__) && defined(__has_warning)
    #if __has_warning("-Wself-assign-overloaded")
        DOCTEST_CLANG_SUPPRESS_WARNING_POP
    #endif
 #endif
 TEST_CASE("regression test #5122 - nlohmann::ordered_map move-assignment transfers contents")
 {
    nlohmann::ordered_map<std::string, std::string> src;
    src.emplace("first", "1");
    src.emplace("second", "2");
    nlohmann::ordered_map<std::string, std::string> dst;
    dst.emplace("stale", "x");
    dst = std::move(src);
    REQUIRE(dst.size() == 2);
    auto it = dst.begin();
    CHECK(it->first == "first");
    CHECK(it->second == "1");
    ++it;
    CHECK(it->first == "second");
    CHECK(it->second == "2");
    // Re-assigning into the moved-from object must leave it in a usable state.
    src = nlohmann::ordered_map<std::string, std::string> {};
    src.emplace("after-move", "3");
    REQUIRE(src.size() == 1);
    CHECK(src.begin()->first == "after-move");
 }
 // Stand-in for a third-party library (e.g., Eigen as of 3.4, which added
 // STL-compatible begin()/end() to its vector types), living in its own
 // namespace with its own to_json overload for its vector type.
 namespace issue_4320_eigen
 {
 // "array-compatible" from the library's point of view (it has begin()/end()),
 // but for which this (fake) third-party namespace provides its own to_json.
 struct vector3
 {
    double v[3]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-use-default-member-init,modernize-use-default-member-init)
    vector3(double x, double y, double z) : v{x, y, z} {} // NOLINT(hicpp-member-init,cppcoreguidelines-pro-type-member-init)
    double x() const
    {
        return v[0];
    }
    double y() const
    {
        return v[1];
    }
    double z() const
    {
        return v[2];
    }
    double* begin()
    {
        return v;
    }
    double* end()
    {
        return v + 3;
    }
    const double* begin() const
    {
        return v;
    }
    const double* end() const
    {
        return v + 3;
    }
 };
 inline void to_json(json& j, const vector3& v) // NOLINT(misc-use-internal-linkage)
 {
    j = {{"x", v.x()}, {"y", v.y()}, {"z", v.z()}};
 }
 } // namespace issue_4320_eigen
 // The user's own namespace, using the (fake) Eigen type as an implementation
 // detail behind a payload type that has nothing to do with vectors/arrays.
 namespace issue_4320
 {
 // Publicly derives from issue_4320_eigen::vector3 but does *not* define its
 // own to_json - it is only ever used as a temporary to reach the base
 // class's to_json via ADL.
 struct vector3_wrapper : issue_4320_eigen::vector3
 {
    using issue_4320_eigen::vector3::vector3;
 };
 struct payload
 {
    double x, y, z;
 };
 inline vector3_wrapper to_eigen(const payload& p) // NOLINT(misc-use-internal-linkage)
 {
    return {p.x, p.y, p.z};
 }
 inline void to_json(json& j, const payload& p) // NOLINT(misc-use-internal-linkage)
 {
    // Unqualified call, passing a *derived* vector3_wrapper: relies on ADL
    // finding issue_4320_eigen::to_json(json&, const vector3&) through the
    // vector3 base class, via a derived-to-base conversion. Must NOT resolve
    // to the library's own generic array-compatible to_json (an exact-match
    // template for vector3_wrapper, since it also has begin()/end()), which
    // would serialize this as [x, y, z] instead of {"x":x, "y":y, "z":z}.
    to_json(j, to_eigen(p));
 }
 } // namespace issue_4320
 TEST_CASE("issue #4320 - custom base class must not leak nlohmann::detail into ADL")
 {
    // Before the fix, basic_json unconditionally derived from a type living in
    // nlohmann::detail (json_default_base), which made nlohmann::detail an
    // associated namespace of every basic_json for ADL purposes. That leaked
    // the library's internal generic-array to_json overload into unqualified
    // to_json() calls made from user code, silently bypassing user-defined
    // to_json overloads reached via a derived-to-base conversion.
    const issue_4320::payload p{1.0, 2.0, 3.0};
    json j;
    to_json(j, p);
    CHECK(j == json({{"x", 1.0}, {"y", 2.0}, {"z", 3.0}}));
 }
 TEST_CASE("issue #5338 - truncated CBOR tagged binary subtype is rejected")
 {
    const std::vector<std::vector<std::uint8_t>> truncated_tags =
    {
        {0xD8},
        {0xD9, 0x00},
        {0xDA, 0x00, 0x00, 0x00},
        {0xDB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
    };
    for (const auto& data : truncated_tags)
    {
        CAPTURE(data);
        for (const auto tag_handler :
                {
                    json::cbor_tag_handler_t::ignore, json::cbor_tag_handler_t::store
                })
        {
            CAPTURE(tag_handler);
            const auto result = json::from_cbor(data, true, false, tag_handler);
            CHECK(result.is_discarded());
        }
    }
 }
 TEST_CASE("issue #5402 - update(merge_objects=true) overwrites a primitive with an object")
 {
    json t = {{"k", 1}};
    t.update(json{{"k", {{"x", 2}}}}, true);
    CHECK(t == json({{"k", {{"x", 2}}}}));
    json mixed = {{"keep", {{"a", 1}}}, {"replace", 1}};
    mixed.update(json{{"keep", {{"b", 2}}}, {"replace", {{"x", 2}}}}, true);
    CHECK(mixed == json({{"keep", {{"a", 1}, {"b", 2}}}, {"replace", {{"x", 2}}}}));
 }
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -15,6 +15,8 @@ using nlohmann::json;
 #include <sstream>
 #include <iomanip>
 #include "test_utils.hpp"
 TEST_CASE("serialization")
 {
    SECTION("operator<<")
@@ -84,8 +86,9 @@ TEST_CASE("serialization")
        {
            const json j = "ä\xA9ü";
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_WITH_AS(j.dump(1, ' ', false, json::error_handler_t::strict), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), "[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9", json::type_error&);
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"äü\"");
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"ä\xEF\xBF\xBDü\"");
            CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"\\u00e4\\ufffd\\u00fc\"");
@@ -95,8 +98,9 @@ TEST_CASE("serialization")
        {
            const json j = "123\xC2";
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_AS(j.dump(1, ' ', false, json::error_handler_t::strict), json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
            CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&);
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123\"");
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\"");
            CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd\"");
@@ -106,8 +110,9 @@ TEST_CASE("serialization")
        {
            const json j = "123\xF1\xB0\x34\x35\x36";
-            CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&);
+            // dump() is nodiscard; the exception is thrown by dump() itself before it would return
-            CHECK_THROWS_AS(j.dump(1, ' ', false, json::error_handler_t::strict), json::type_error&);
+            CHECK_THROWS_WITH_AS(utils::ignore_return_value(j.dump()), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0x34", json::type_error&);
            CHECK_THROWS_AS(utils::ignore_return_value(j.dump(1, ' ', false, json::error_handler_t::strict)), json::type_error&);
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"123456\"");
            CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"123\xEF\xBF\xBD\x34\x35\x36\"");
            CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"123\\ufffd456\"");
@@ -382,232 +387,3 @@ TEST_CASE("dump for basic_json with long double number_float_t")
        check_same(100.0L,  100.0);
    }
 }
 TEST_CASE("serialization of strings (bulk fast path)")
 {
    // These cases exercise the SWAR bulk-copy fast path in dump_escaped and the
    // internal write buffer: long runs, escapes interrupting runs, 0x7F/DEL,
    // multibyte UTF-8 under both ensure_ascii settings, and payloads larger than
    // the write buffer.
    SECTION("long unescaped ASCII exceeds the write buffer")
    {
        const std::string big(3000, 'a');
        const json j = big;
        CHECK(j.dump() == '"' + big + '"');
        CHECK(j.dump(-1, ' ', true) == '"' + big + '"');
        // round-trips
        CHECK(json::parse(j.dump()) == j);
    }
    SECTION("runs interrupted by escapes")
    {
        const json j = std::string(500, 'x') + "\n\"\\" + std::string(500, 'y');
        const std::string out = j.dump();
        CHECK(out == '"' + std::string(500, 'x') + "\\n\\\"\\\\" + std::string(500, 'y') + '"');
        CHECK(json::parse(out) == j);
    }
    SECTION("DEL (0x7F) depends on ensure_ascii")
    {
        const json j = std::string("a\x7f" "b");
        CHECK(j.dump(-1, ' ', false) == "\"a\x7f" "b\"");   // copied verbatim
        CHECK(j.dump(-1, ' ', true) == "\"a\\u007fb\"");    // escaped
    }
    SECTION("multibyte UTF-8 under both ensure_ascii settings")
    {
        const json j = std::string("A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z"); // A é 你 😀 Z
        // not escaping non-ASCII: bytes are copied through the bulk validator
        CHECK(j.dump(-1, ' ', false) == "\"A\xc3\xa9\xe4\xbd\xa0\xf0\x9f\x98\x80Z\"");
        // ensure_ascii: escaped (with a surrogate pair for the emoji)
        CHECK(j.dump(-1, ' ', true) == "\"A\\u00e9\\u4f60\\ud83d\\ude00Z\"");
        CHECK(json::parse(j.dump(-1, ' ', true)) == j);
    }
    SECTION("many small structural writes exceed the write buffer")
    {
        json arr = json::array();
        for (int i = 0; i < 2000; ++i)
        {
            arr.push_back(i);
        }
        const std::string out = arr.dump();
        CHECK(out.front() == '[');
        CHECK(out.back() == ']');
        CHECK(json::parse(out) == arr);
        json obj = json::object();
        for (int i = 0; i < 500; ++i)
        {
            obj["key" + std::to_string(i)] = i;
        }
        CHECK(json::parse(obj.dump()) == obj);
        CHECK(json::parse(obj.dump(2)) == obj);
        // an array of many empty strings emits a long run of single-character
        // writes ('"', '"', ',') at shallow nesting depth, so the write buffer
        // fills and flushes mid-run without the deep recursion that would
        // overflow the stack on some debug builds
        json many_empty = json::array();
        for (int i = 0; i < 500; ++i)
        {
            many_empty.push_back("");
        }
        const std::string out2 = many_empty.dump();
        CHECK(out2.size() > 1024); // spans multiple write-buffer flushes
        CHECK(out2.front() == '[');
        CHECK(out2.back() == ']');
        CHECK(json::parse(out2) == many_empty);
    }
    SECTION("invalid UTF-8 handling is unaffected by the fast path")
    {
        const json j = std::string("valid\xff" "more");
        CHECK_THROWS_WITH_AS(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 5: 0xFF", json::type_error&);
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::replace) == "\"valid\xef\xbf\xbd" "more\"");
        CHECK(j.dump(-1, ' ', true, json::error_handler_t::replace) == "\"valid\\ufffdmore\"");
        CHECK(j.dump(-1, ' ', false, json::error_handler_t::ignore) == "\"validmore\"");
    }
 }
 TEST_CASE("indentation is written straight into the write buffer")
 {
    // put_indent() memsets the indentation into the write buffer instead of
    // copying it out of a pre-grown indentation string. These cases cover an
    // indentation wider than the buffer, a non-space indentation character, and
    // nesting deep enough that the accumulated indentation spans several
    // buffer-fulls - the situations the old grow-a-string approach got wrong.
    SECTION("indent_step wider than the write buffer")
    {
        const json j = {{"a", 1}};
        // 2000 > the 1024-byte write buffer, and > the 512 the indentation
        // string used to start at
        CHECK(j.dump(2000) == "{\n" + std::string(2000, ' ') + "\"a\": 1\n}");
        // several whole buffer-fulls, so the buffer is refilled once and then
        // flushed repeatedly
        CHECK(j.dump(5000) == "{\n" + std::string(5000, ' ') + "\"a\": 1\n}");
        CHECK(j.dump(5000, '\t') == "{\n" + std::string(5000, '\t') + "\"a\": 1\n}");
        // an exact multiple of the buffer size
        CHECK(j.dump(4096) == "{\n" + std::string(4096, ' ') + "\"a\": 1\n}");
    }
    SECTION("a non-space indentation character is used throughout")
    {
        const json j = {{"a", 1}};
        // 600 is past the point where the indentation used to be grown, which
        // is where a hard-coded space would have shown up
        CHECK(j.dump(600, '\t') == "{\n" + std::string(600, '\t') + "\"a\": 1\n}");
        CHECK(j.dump(3, '.') == "{\n...\"a\": 1\n}");
    }
    SECTION("accumulated indentation spans several buffer-fulls")
    {
        // five levels deep at 400 per level: the innermost value is indented by
        // 2000 characters, reached in steps that each straddle the buffer end
        json j = json::array({1});
        for (int i = 0; i < 4; ++i)
        {
            j = json::array({j});
        }
        const std::string out = j.dump(400);
        CHECK(out.find(std::string("\n") + std::string(2000, ' ') + "1\n") != std::string::npos);
        CHECK(json::parse(out) == j);
    }
    SECTION("indentation is unchanged for ordinary widths")
    {
        const json j = {{"a", {1, 2}}, {"b", nullptr}};
        CHECK(j.dump(2) == "{\n  \"a\": [\n    1,\n    2\n  ],\n  \"b\": null\n}");
        CHECK(j.dump(0) == "{\n\"a\": [\n1,\n2\n],\n\"b\": null\n}");
    }
 }
 TEST_CASE("serialization of deeply nested values")
 {
    // dump() descends into a bounded number of levels and writes out whatever
    // is nested deeper than that without the call stack; see
    // https://github.com/nlohmann/json/issues/5387
    SECTION("nested deeper than the call stack could follow")
    {
        // parsing is iterative, so building these costs little
        const std::size_t depth = 100000;
        const std::string array_text = std::string(depth, '[') + '0' + std::string(depth, ']');
        CHECK(json::parse(array_text).dump() == array_text);
        std::string object_text;
        object_text.reserve((6 * depth) + 1);
        for (std::size_t i = 0; i < depth; ++i)
        {
            object_text += "{\"a\":";
        }
        object_text += '1';
        object_text.append(depth, '}');
        CHECK(json::parse(object_text).dump() == object_text);
    }
    SECTION("depths around the bound of the descent")
    {
        // Cover every depth around the bound, so that the two ways of writing a
        // value are known to meet cleanly - wherever the bound is set.
        for (std::size_t d = 1; d <= 300; ++d)
        {
            CAPTURE(d);
            const std::string array_text = std::string(d, '[') + '7' + std::string(d, ']');
            CHECK(json::parse(array_text).dump() == array_text);
            std::string object_text;
            for (std::size_t i = 0; i < d; ++i)
            {
                object_text += "{\"k\":";
            }
            object_text += '7';
            object_text.append(d, '}');
            CHECK(json::parse(object_text).dump() == object_text);
        }
    }
    SECTION("pretty-printing across the bound")
    {
        for (std::size_t d = 120; d <= 140; ++d)
        {
            CAPTURE(d);
            const json j = json::parse(std::string(d, '[') + '7' + std::string(d, ']'));
            std::string expected;
            for (std::size_t i = 0; i < d; ++i)
            {
                expected += std::string(2 * i, ' ') + "[\n";
            }
            expected += std::string(2 * d, ' ') + '7';
            for (std::size_t i = d; i > 0; --i)
            {
                expected += '\n' + std::string(2 * (i - 1), ' ') + ']';
            }
            CHECK(j.dump(2) == expected);
        }
    }
    SECTION("an empty container below the bound")
    {
        // an empty container is written out in full and never descended into,
        // so it must not gain a newline when it is reached iteratively
        for (std::size_t d = 125; d <= 135; ++d)
        {
            CAPTURE(d);
            const std::string compact = std::string(d, '[') + "[]" + std::string(d, ']');
            CHECK(json::parse(compact).dump() == compact);
            const std::string with_object = std::string(d, '[') + "{}" + std::string(d, ']');
            CHECK(json::parse(with_object).dump() == with_object);
        }
    }
 }
@@ -2149,6 +2149,67 @@ TEST_CASE("UBJSON")
    }
 }
 TEST_CASE("UBJSON optimized arrays of a valueless type are bounded")
 {
    // An element of type 'Z', 'T' or 'F' is encoded by its marker alone, so an
    // optimized array of one of those has no payload and the declared count is
    // the only thing deciding how much is allocated. Ten bytes used to produce
    // billions of values (#2793); every other type costs at least one byte per
    // element and is bounded by the end of the input.
    json _;
    SECTION("an excessive count is rejected")
    {
        // 'l' is a big-endian int32: 0x7FFFFFFF elements, about 34 GB of value
        for (const auto marker :
                {'Z', 'T', 'F'
                })
        {
            const std::vector<uint8_t> input = {'[', '$', static_cast<uint8_t>(marker), '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF};
            CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size", json::out_of_range&);
            CHECK(json::from_ubjson(input, true, false).is_discarded());
        }
    }
    SECTION("ordinary counts are unaffected")
    {
        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'Z', '#', 'i', 3})) == json({nullptr, nullptr, nullptr}));
        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'T', '#', 'i', 2})) == json({true, true}));
        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'F', '#', 'i', 2})) == json({false, false}));
        // 'N' is a no-op rather than a value, and still yields an empty array
        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'N', '#', 'i', 2})) == json::array());
    }
    SECTION("a type with a payload is unaffected")
    {
        // A count past the limit is not rejected for 'U', which costs a byte
        // per element and is bounded by the end of the input instead. The
        // count is kept just past the limit rather than made huge, because a
        // count that also exceeds the array's max_size() is reported as
        // out_of_range before the input runs out, and max_size() depends on
        // the width of std::size_t.
        const std::vector<uint8_t> input = {'[', '$', 'U', '#', 'l', 0x00, 0x10, 0x00, 0x01};
        CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON number: unexpected end of input", json::parse_error&);
        CHECK(json::from_ubjson(input, true, false).is_discarded());
    }
    SECTION("the writer stays within what the reader accepts")
    {
        // below the limit the optimized form is used and is tiny; above it the
        // writer falls back so that the result can still be read back
        json const at_limit(1048576, nullptr);
        const auto v_at_limit = json::to_ubjson(at_limit, true, true);
        CHECK(v_at_limit.size() == 9);
        CHECK(v_at_limit.at(1) == '$');
        CHECK(json::from_ubjson(v_at_limit) == at_limit);
        json const above_limit(1048577, nullptr);
        const auto v_above_limit = json::to_ubjson(above_limit, true, true);
        CHECK(v_above_limit.at(1) != '$');
        CHECK(json::from_ubjson(v_above_limit) == above_limit);
    }
 }
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
    SECTION("Null Value")
@@ -17,6 +17,7 @@ using nlohmann::json;
 #include <sstream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 TEST_CASE("Unicode (1/5)" * doctest::skip())
 {
@@ -240,7 +241,8 @@ void roundtrip(bool success_expected, const std::string& s)
    if (success_expected)
    {
        // serialization succeeds
-        CHECK_NOTHROW(j.dump());
+        // dump() is nodiscard; this only checks that dumping does not throw
        CHECK_NOTHROW(utils::ignore_return_value(j.dump()));
        // exclude parse test for U+0000
        if (s[0] != '\0')
@@ -259,7 +261,8 @@ void roundtrip(bool success_expected, const std::string& s)
    else
    {
        // serialization fails
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
        // parsing JSON text fails
        CHECK_THROWS_AS(_ = json::parse(ps), json::parse_error&);
@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
    else
    {
        // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
        // ignore and replace must create different dumps
        CHECK(s_ignored != s_replaced);
@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
    else
    {
        // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
        // ignore and replace must create different dumps
        CHECK(s_ignored != s_replaced);
@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
    else
    {
        // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
        // ignore and replace must create different dumps
        CHECK(s_ignored != s_replaced);
@@ -19,6 +19,7 @@ using nlohmann::json;
 #include <iostream>
 #include <iomanip>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 // this test suite uses static variables with non-trivial destructors
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
@@ -97,7 +98,8 @@ void check_utf8dump(bool success_expected, int byte1, int byte2 = -1, int byte3
    else
    {
        // strict mode must throw if success is not expected
-        CHECK_THROWS_AS(j.dump(), json::type_error&);
+        // dump() is nodiscard; the exception is thrown by dump() itself before it would return
        CHECK_THROWS_AS(utils::ignore_return_value(j.dump()), json::type_error&);
        // ignore and replace must create different dumps
        CHECK(s_ignored != s_replaced);
@@ -18,12 +18,7 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <array> // array
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t
 #include <list>
 #include <string> // string
 #include <vector> // vector
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
    #include <iterator>
@@ -217,66 +212,6 @@ TEST_CASE("Parse with heterogeneous iterator and sentinel types")
    CHECK(j2.at(0) == 1);
 }
 // A type whose data() hands out raw bytes but whose size() counts something
 // else - here fixed-size records. Reading [data(), data() + size()) as bytes
 // would silently truncate the input, so data() and size() alone must not be
 // taken as evidence of contiguous byte storage.
 struct record_buffer
 {
    using value_type = std::array<char, 4>;
    std::string bytes;
    const char* data() const noexcept
    {
        return bytes.data();
    }
    std::size_t size() const noexcept
    {
        return bytes.size() / sizeof(value_type);
    }
    const char* begin() const noexcept
    {
        return bytes.data();
    }
    const char* end() const noexcept
    {
        return bytes.data() + bytes.size();
    }
 };
 TEST_CASE("Contiguous byte containers take the pointer adapter")
 {
    // Containers with contiguous single-byte storage are routed through the
    // pointer-based adapter so the bulk fast paths apply in every standard, not
    // only in C++20 where the library iterators model std::contiguous_iterator.
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::string>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::vector<char>>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::vector<std::uint8_t>>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::array<char, 4>>::value);
    // input_adapter() takes its container by forwarding reference, so the trait
    // is also asked about reference types
    CHECK(nlohmann::detail::is_contiguous_byte_container<std::string&>::value);
    CHECK(nlohmann::detail::is_contiguous_byte_container<const std::string&>::value);
    // everything else keeps the iterator-based adapter
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<std::list<char>>::value);
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<std::vector<int>>::value);
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<const char*>::value);
    // including a type that has data() and size() but whose size() does not
    // count the units data() points at: its value_type says so
    CHECK_FALSE(nlohmann::detail::is_contiguous_byte_container<record_buffer>::value);
    // and such a container still parses through its iterators, in full - taking
    // it for a byte container would stop after data() + size() bytes
    const record_buffer buffer{"[1,2,3,4,5]"};
    CHECK(buffer.data() == buffer.bytes.data());
    CHECK(buffer.size() * sizeof(record_buffer::value_type) < buffer.bytes.size());
    CHECK(json::parse(buffer) == json({1, 2, 3, 4, 5}));
 }
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
 // JSON_HAS_CPP_20 (do not remove; see note at top of file)
 TEST_CASE("Parse with std::counted_iterator and std::default_sentinel_t")
@@ -293,180 +228,6 @@ TEST_CASE("Parse with std::counted_iterator and std::default_sentinel_t")
    const std::counted_iterator<iterator_type> first2(json_str.begin(), len);
    CHECK(json::accept(first2, std::default_sentinel));
 }
 TEST_CASE("std::counted_iterator reaches the contiguous fast paths")
 {
    // A sized sentinel makes the remaining element count computable in O(1), so
    // std::counted_iterator over a contiguous iterator must reach the same bulk
    // string/number scanners as a plain pointer - not just the byte-at-a-time
    // fallback (see #5268 for the equivalent memcpy fast path).
 #if JSON_HAS_RANGES
    // JSON_HAS_RANGES is 0 on standard libraries with an incomplete <ranges>
    // (libstdc++ < 11, libc++ < 16), where the adapter deliberately falls back
    // to the byte-at-a-time scanner; everything below still has to work there.
    using adapter_type = nlohmann::detail::iterator_input_adapter<std::counted_iterator<const char*>, std::default_sentinel_t>;
    CHECK(adapter_type::supports_bulk_scan);
    CHECK(adapter_type::supports_seek);
 #endif
    // exercise every fast path: long ASCII run, multibyte UTF-8, escapes, and
    // integer/floating-point numbers
    const std::string json_str =
        R"({"ascii":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",)"
        "\"utf8\":\"\xe4\xb8\xad\xe6\x96\x87\xf0\x9f\x98\x80\xc3\xa9\","
        R"("escaped":"aéb\n\\","ints":[0,-1,18446744073709551615,-9223372036854775808],)"
        R"("floats":[1.5,-2.25e3,0.30000000000000004]})";
    const auto len = static_cast<std::iter_difference_t<const char*>>(json_str.size());
    const std::counted_iterator<const char*> first(json_str.data(), len);
    const json j = json::parse(first, std::default_sentinel);
    // parsing through the pointer adapter must give exactly the same result
    CHECK(j == json::parse(json_str));
 #if !defined(JSON_NOEXCEPTION)
    // Diagnostics that quote the offending token are reconstructed from the
    // already-consumed input (supports_seek), a path a sized sentinel only
    // reaches now; check a few that include the "last read" text. Parsing
    // invalid input aborts when exceptions are off, hence the guard.
    // Raw strings and explicit bytes: an escaped literal and two literals
    // written next to each other both read as mistakes to static analysis.
    const auto byte = [](int value)
    {
        return std::string(1, static_cast<char>(value));
    };
    const std::vector<std::string> diagnostic_docs =
    {
        "1\nx",
        "truX",
        "[tru]",
        R"("abc)",
        R"(["\ud834"])",
        R"(["a)" + byte(0x01) + R"(b"])",
        R"([")" + byte(0xC3) + byte(0x28) + R"("])",
        "[1e]",
        R"(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaX)"
    };
    for (const auto& text : diagnostic_docs)
    {
        CAPTURE(text);
        const std::counted_iterator<const char*> it(text.data(), static_cast<std::iter_difference_t<const char*>>(text.size()));
        std::string counted_message;
        std::string string_message;
        try
        {
            const json counted_result = json::parse(it, std::default_sentinel);
            static_cast<void>(counted_result);
        }
        catch (const json::parse_error& e)
        {
            counted_message = e.what();
        }
        try
        {
            const json string_result = json::parse(text);
            static_cast<void>(string_result);
        }
        catch (const json::parse_error& e)
        {
            string_message = e.what();
        }
        CHECK_FALSE(counted_message.empty());
        CHECK(counted_message == string_message);
    }
    // and errors must still be reported identically
    const std::string bad = "[01\n]";
    const std::counted_iterator<const char*> bad_first(bad.data(), static_cast<std::iter_difference_t<const char*>>(bad.size()));
    std::string counted_what;
    std::string string_what;
    try
    {
        const json counted_result = json::parse(bad_first, std::default_sentinel);
        static_cast<void>(counted_result);
    }
    catch (const json::parse_error& e)
    {
        counted_what = e.what();
    }
    try
    {
        const json string_result = json::parse(bad);
        static_cast<void>(string_result);
    }
    catch (const json::parse_error& e)
    {
        string_what = e.what();
    }
    CHECK_FALSE(counted_what.empty());
    CHECK(counted_what == string_what);
 #endif
 }
 #if !defined(JSON_NOEXCEPTION)
 // several cases below are truncated on purpose, and parsing invalid input
 // aborts when exceptions are off
 TEST_CASE("std::counted_iterator bulk scanning stops at the counted end")
 {
    // The count, not the size of the underlying buffer, is the end of the
    // input: the bulk scanners must never look at the bytes behind it, even
    // though they are readable. Each case is compared against parsing the
    // equivalent prefix as a std::string.
    const auto via_counted = [](const std::string & buf, std::size_t n) -> std::string
    {
        const std::counted_iterator<const char*> first(buf.data(), static_cast<std::iter_difference_t<const char*>>(n));
        try
        {
            const json j = json::parse(first, std::default_sentinel);
            return "OK|" + j.dump();
        }
        catch (const json::parse_error& e)
        {
            return {e.what()};
        }
    };
    const auto via_prefix = [](const std::string & buf, std::size_t n) -> std::string
    {
        try
        {
            const json j = json::parse(buf.substr(0, n));
            return "OK|" + j.dump();
        }
        catch (const json::parse_error& e)
        {
            return {e.what()};
        }
    };
    struct testcase // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
    {
        const char* buffer;
        std::size_t count;
    };
    const std::vector<testcase> cases =
    {
        {"[\"abc\"]____TRAILING____", 7},                    // exact fit, tail hidden
        {"[\"abcdefghijklmnop\"]____", 8},                   // cut inside a string
        {"[\"abc\"]____", 6},                                // cut just before the closing quote
        {"[12345]xxxxx", 4},                                 // cut inside a number
        {"[123]999999", 5},                                  // number ends exactly at the count
        {"[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"]", 12},        // closing quote only behind the count
        {"[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"]", 19},      // cut inside an 8-byte SWAR stride
        {"[\"\xe4\xb8\xad\xe6\x96\x87\"]", 5},               // cut inside a UTF-8 sequence
        {"[\"\xe4\xb8\xad\xe6\x96\x87\"]____", 10},          // complete UTF-8, tail hidden
        {"[1.25e3]TRAILINGDIGITS999", 7},                    // number token reaches the count
    };
    for (const auto& tc : cases)
    {
        CAPTURE(tc.buffer);
        CAPTURE(tc.count);
        const std::string buffer = tc.buffer;
        CHECK(via_counted(buffer, tc.count) == via_prefix(buffer, tc.count));
    }
 }
 #endif
 #endif
 } // namespace