🤜 Doctest 2.5.3

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-07-11 04:55:10 +00:00 · 2026-07-08 11:04:03 +02:00
93 changed files with 7278 additions and 6310 deletions
@@ -4,8 +4,6 @@ updates:
    directory: /
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7
    groups:
      codeql-action:
        patterns:
@@ -15,33 +13,23 @@ updates:
    directory: /docs/mkdocs
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7

  - package-ecosystem: pip
    directory: /tools/astyle
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7

  - package-ecosystem: pip
    directory: /tools/generate_natvis
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7

  - package-ecosystem: pip
    directory: /tools/serve_header
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7

  - package-ecosystem: pip
    directory: /cmake/requirements
    schedule:
      interval: daily
-    cooldown:
-      default-days: 7
@@ -49,7 +49,7 @@ jobs:
      # SEMGREP_APP_TOKEN is still passed through so registry auth works if a
      # token is ever added.
      - name: Install Semgrep
-        run: python3 -m pip install --user semgrep==1.168.0
+        run: python3 -m pip install --user semgrep

      # `semgrep scan --sarif` always exits 0 even with findings; continue-on-error
      # is a safety net so the SARIF upload still runs if the scan itself errors.
@@ -33,21 +33,11 @@ jobs:

  ci_infer:
    runs-on: ubuntu-latest
+    container: ghcr.io/nlohmann/json-ci:v2.4.0
    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
-        with:
-          egress-policy: audit
-
-      - name: Install Infer
-        run: |
-          wget -q -O - "https://github.com/facebook/infer/releases/download/v1.3.0/infer-linux-x86_64-v1.3.0.tar.xz" | sudo tar -C /opt -xJ
-          sudo ln -s /opt/infer-linux-x86_64-v1.3.0/bin/infer /usr/local/bin/infer
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -153,30 +143,11 @@ jobs:
    strategy:
      matrix:
        compiler: ['4.8', '4.9', '5', '6']
-    # official gcc:4.8/4.9/5/6 images fail to check out code (too old for
-    # actions/checkout); install the old compilers on top of official ubuntu:20.04
-    # instead, mirroring what the (now retired) custom json-ci image did.
-    container: ubuntu:20.04
+    container: ghcr.io/nlohmann/json-ci:v2.4.0
    steps:
-      - name: Install g++-${{ matrix.compiler }}
-        run: |
-          export DEBIAN_FRONTEND=noninteractive
-          apt-get update
-          apt-get install -y --no-install-recommends software-properties-common ca-certificates gnupg make git
-          add-apt-repository -y ppa:ubuntu-toolchain-r/test
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic main"
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic universe"
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial main"
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial universe"
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial-updates main"
-          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial-updates universe"
-          apt-get update
-          apt-get install -y --no-install-recommends g++-${{ matrix.compiler }}
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: CXX=g++-${{ matrix.compiler }} cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -263,22 +234,11 @@ jobs:

  ci_cuda_example:
    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        # 11.8.0: newest pre-C++20 CUDA release, exercises the C++17 fallback
-        # path (tests/cuda_example/CMakeLists.txt picks the standard per nvcc
-        # version); 12.1.1: permanent regression guard for #3907 (nvcc 12.0/12.1
-        # choke on enable_borrowed_range at C++20, fixed in 12.2); 12.6.3: recent
-        # CUDA/C++20 coverage.
-        cuda: ['11.8.0', '12.1.1', '12.6.3']
-    container: nvidia/cuda:${{ matrix.cuda }}-devel-ubuntu22.04
+    container: ghcr.io/nlohmann/json-ci:v2.4.0
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -316,22 +276,17 @@ jobs:

  ci_icpc:
    runs-on: ubuntu-latest
-    # Intel discontinued the classic icc/icpc compiler in oneAPI 2024.0; this is
-    # Intel's own last officially published image that still includes it.
-    container: intel/oneapi-hpckit:2023.2.1-devel-ubuntu22.04
+    container: ghcr.io/nlohmann/json-ci:v2.2.0
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
-        # No need to source setvars.sh here: unlike the old custom image, this
-        # official image already has the oneAPI environment (icc/icpc on PATH)
-        # baked in, and re-sourcing it fails with "already been run" (exit 3).
-        run: cmake --build build --target ci_icpc
+        run: |
+          . /opt/intel/oneapi/setvars.sh
+          cmake --build build --target ci_icpc

  ci_icpx:
    runs-on: ubuntu-latest
@@ -90,13 +90,11 @@ jobs:
      - name: Get latest CMake and ninja
        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Set extra CXX_FLAGS for latest std_version
-        # /wd5285 silences C5285 emitted by the bundled third-party doctest.h, which
-        # specializes std::tuple (newly diagnosed by the VS2026 v145 toolset)
        run: |
          if [ "${{ matrix.std_version }}" = "latest" ]; then
-            echo "flags=/permissive- /std:c++latest /utf-8 /W4 /WX /wd5285" >> $GITHUB_ENV
+            echo "flags=/permissive- /std:c++latest /utf-8 /W4 /WX" >> $GITHUB_ENV
          else
-            echo "flags=/W4 /WX /wd5285" >> $GITHUB_ENV
+            echo "flags=/W4 /WX" >> $GITHUB_ENV
          fi
        shell: bash
      - name: Run CMake (Release)
@@ -669,6 +669,7 @@ add_custom_target(ci_test_compiler_default
 add_custom_target(ci_cuda_example
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_BUILD_TYPE=Debug -GNinja
+        -DCMAKE_CUDA_HOST_COMPILER=g++-8
        -S${PROJECT_SOURCE_DIR}/tests/cuda_example -B${PROJECT_BINARY_DIR}/build_cuda_example
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_cuda_example
 )
@@ -719,11 +720,6 @@ add_custom_target(ci_icpx
 # to zero and does not honor NaN ordering; -Kieee restores strict IEEE 754 behavior
 # (needed for the dtoa/grisu and NaN-comparison code paths).
 #
-# -tp=px pins the target processor to the generic x86-64 baseline (SSE2-only) to avoid
-# a nvc++ 25.5 / LLVM issue: when nvc++ auto-detects -tp from the runner's CPU (e.g. -tp znver4),
-# certain attribute combinations trigger an llc instruction-selection crash on std::ldexp<unsigned>.
-# Pinning to px removes this variability and is robust to future llc/nvc++ updates.
-#
 # The following tests are excluded as they trigger known nvc++ 25.5 defects (not
 # library bugs); see https://github.com/nlohmann/json for tracking. Only the
 # affected language-standard variants are excluded so coverage is otherwise kept:
@@ -737,7 +733,7 @@ add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_BUILD_TYPE=Debug -GNinja
        -DCMAKE_C_COMPILER=nvc -DCMAKE_CXX_COMPILER=nvc++
-        -DCMAKE_CXX_FLAGS="-Kieee;-tp=px"
+        -DCMAKE_CXX_FLAGS=-Kieee
        -DJSON_BuildTests=ON -DJSON_FastTests=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_nvhpc
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_nvhpc
@@ -5,11 +5,8 @@
 # -Wno-extra-semi-stmt            The library uses assert which triggers this warning.
 # -Wno-padded                     We do not care about padding warnings.
 # -Wno-covered-switch-default     All switches list all cases and a default case.
-# -Wno-unsafe-buffer-usage        Pervasive: the library's own low-level numeric/buffer code
-#                                 (to_chars, serializer, lexer, binary reader/writer, input
-#                                 adapters, json_pointer) plus vendored Doctest itself (~208
-#                                 distinct sites measured 2026-07-08 on clang trunk) all use
-#                                 raw pointer arithmetic / libc string calls by necessity.
+# -Wno-unsafe-buffer-usage        Otherwise library code (strlen) would not compile.
+# -Wno-missing-noreturn           We found no way to silence this warning otherwise, see PR #4871

 set(CLANG_CXXFLAGS
    -Werror
@@ -21,4 +18,5 @@ set(CLANG_CXXFLAGS
    -Wno-padded
    -Wno-covered-switch-default
    -Wno-unsafe-buffer-usage
+    -Wno-missing-noreturn
 )
@@ -4,7 +4,6 @@
 # -Wno-aggregate-return  The library uses aggregate returns.
 # -Wno-long-long         The library uses the long long type to interface with system functions.
 # -Wno-namespaces        The library uses namespaces.
-# -Wno-nrvo              Doctest triggers this warning.
 # -Wno-padded            We do not care about padding warnings.
 # -Wno-system-headers    We do not care about warnings in system headers.
 # -Wno-templates         The library uses templates.
@@ -232,7 +231,6 @@ set(GCC_CXXFLAGS
    -Wnonnull
    -Wnonnull-compare
    -Wnormalized=nfkc
-    -Wno-nrvo
    -Wnull-dereference
    -Wodr
    -Wold-style-cast
@@ -4,7 +4,7 @@
  "archive": "JSON_for_Modern_C++.tgz",
  "author": {
    "name": "Niels Lohmann",
-    "link": "https://nlohmann.me"
+    "link": "https://twitter.com/nlohmann"
  },
  "aliases": ["nlohmann/json"]
 }
@@ -35,8 +35,7 @@ Unlike the [`parse()`](parse.md) function, this function neither throws an excep
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters (throws if null)
    - a `std::string`
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type, for instance.
@@ -110,8 +109,7 @@ A UTF-8 byte order mark is silently ignored.
 - Added in version 3.0.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
 - Changed [runtime assertion](../../features/assertions.md) in case of `FILE*` null pointers to exception in version 3.12.0.
- Added `ignore_trailing_commas` in version 3.13.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
+- Added `ignore_trailing_commas` in version 3.12.x.

 !!! warning "Deprecation"

@@ -82,13 +82,7 @@ basic_json(basic_json&& other) noexcept;
 4. This is a constructor for existing `basic_json` types. It does not hijack copy/move constructors, since the parameter
   has different template arguments than the current ones.

-    The constructor tries to convert the internal `m_value` of the parameter. Each member value (object, array, string,
-    etc.) is serialized via the corresponding `to_json()` overload. For objects and strings, the conversion requires
-    that the *target* `basic_json` type's `object_t::key_type` (or `string_t`) be directly constructible from the
-    *source* type's corresponding member type via `is_constructible`. If this requirement is not met, the conversion
-    does not fail to compile; instead, it silently falls back to the array-conversion path, which represents objects
-    as arrays of `[key, value]` pairs and strings as arrays of character codes. This is a known limitation tracked in
-    [issue #3425](https://github.com/nlohmann/json/issues/3425).
+    The constructor tries to convert the internal `m_value` of the parameter.

 5. Creates a JSON value of type array or object from the passed initializer list `init`. In case `type_deduction` is
   `#!cpp true` (default), the type of the JSON value to be created is deducted from the initializer list `init`
@@ -115,22 +109,7 @@ basic_json(basic_json&& other) noexcept;
   
    Function [`array()`](array.md) and [`object()`](object.md) force array and object creation from initializer lists,
    respectively.
-
-    !!! warning "Brace initialization yields arrays"
-
-        Because this constructor takes an `initializer_list_t`, brace-initializing a `json`/`ordered_json` from
-        another `json` value wraps it in a single-element array rather than copying it:
-
-        ```cpp
-        json j1 = "hello";
-        json j2{j1};   // [!] j2 is ["hello"], NOT a copy of j1
-        json j3(j1);   // j3 is "hello" -- parentheses copy as expected
-        ```
-
-        See the FAQ entry on [brace initialization](../../home/faq.md#brace-initialization-yields-arrays) for the
-        full explanation, an opt-in macro to change this behavior, and how to explicitly create a single-element
-        array (`json::array({value})`) if that is what you want.
-
+        
 6. Constructs a JSON array value by creating `cnt` copies of a passed value. In case `cnt` is `0`, an empty array is
   created.

@@ -167,11 +146,6 @@ basic_json(basic_json&& other) noexcept;

    - `BasicJsonType` is a `basic_json` type.
    - `BasicJsonType` has different template arguments than `basic_json_t`.
-    
-    **Note:** For cross-`basic_json` conversions to produce correct results, the target `basic_json`'s
-    `object_t::key_type` and `string_t` must be directly constructible from the source `basic_json`'s
-    corresponding types. See the description of overload (4) above for details on what happens when
-    this requirement is not met.

 `U`:
 :   `uncvref_t<CompatibleType>`
@@ -37,52 +37,12 @@ represent a byte array in modern C++.
 `BinaryType`
 :   container type to store arrays

-    Although not formally expressed as a C++ concept, `BinaryType` must be default-constructible,
-    copy/move-constructible, and support `push_back()`, `.data()`, and `.size()`, because
-    [`byte_container_with_subtype`](../byte_container_with_subtype/index.md) derives directly from it. Its
-    `value_type` must additionally be exactly one byte wide (e.g., `std::uint8_t`/`char`/`std::byte`): the binary
-    serializers (CBOR, MessagePack, BSON, UBJSON) read and write the container's raw bytes via
-    `reinterpret_cast`, which is only correct for byte-sized elements -- a container like
-    `#!cpp std::vector<std::intptr_t>` will not work as `BinaryType`.
-
 ## Notes

 #### Default type

 The default values for `BinaryType` is `#!cpp std::vector<std::uint8_t>`.

-#### Custom BinaryType behavior
-
-When a custom `BinaryType` is configured (other than the default `#!cpp std::vector<std::uint8_t>`), you can assign
-values of that type directly to a `basic_json` instance, and they will automatically be recognized as binary values
-rather than arrays:
-
-```cpp
-using custom_json = nlohmann::basic_json<
-    nlohmann::ordered_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,
-    std::vector<std::byte>  // Custom BinaryType
->;
-
-std::vector<std::byte> data{std::byte{1}, std::byte{2}, std::byte{3}};
-custom_json j = data;  // Creates a binary value, not an array
-assert(j.is_binary());
-
-// Round-tripping works seamlessly
-auto extracted = j.get<std::vector<std::byte>>();
-assert(extracted == data);
-```
-
-This automatic type detection is a convenience feature that only applies to custom (non-default) `BinaryType` configurations.
-The default `nlohmann::json` continues to treat `#!cpp std::vector<std::uint8_t>` as arrays for backward compatibility.
-
 #### Storage

 Binary Arrays are stored as pointers in a `basic_json` type. That is, for any access to array values, a pointer of the
@@ -92,4 +92,4 @@ std::string format_as(const BasicJsonType& j)

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -29,8 +29,7 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type
@@ -102,4 +101,3 @@ Linear in the size of the input.
 ## Version history

 - Added in version 3.11.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
@@ -29,8 +29,7 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type
@@ -102,7 +101,6 @@ Linear in the size of the input.
 ## Version history

 - Added in version 3.4.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.

 !!! warning "Deprecation"

@@ -32,8 +32,7 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type
@@ -112,7 +111,6 @@ Linear in the size of the input.
 - Changed to consume input adapters, removed `start_index` parameter, and added `strict` parameter in version 3.0.0.
 - Added `allow_exceptions` parameter in version 3.2.0.
 - Added `tag_handler` parameter in version 3.9.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.

 !!! warning "Deprecation"

@@ -29,8 +29,7 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type
@@ -104,7 +103,6 @@ Linear in the size of the input.
 - Parameter `start_index` since version 2.1.1.
 - Changed to consume input adapters, removed `start_index` parameter, and added `strict` parameter in version 3.0.0.
 - Added `allow_exceptions` parameter in version 3.2.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.

 !!! warning "Deprecation"

@@ -29,8 +29,7 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type
@@ -103,7 +102,6 @@ Linear in the size of the input.

 - Added in version 3.1.0.
 - Added `allow_exceptions` parameter in version 3.2.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.

 !!! warning "Deprecation"

@@ -114,13 +114,6 @@ overload (3).
    See [Number conversion](../../features/types/number_handling.md#number-conversion)
    for more information.

-!!! note "`std::optional` conversions"
-
-    Prior to version 3.13.0, `#!cpp get<std::optional<T>>()` (and other conversions to `std::optional<T>`) failed to
-    compile in every configuration, due to an internal implementation bug that made the `from_json` overload for
-    `std::optional` unreachable regardless of the [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md)
-    setting. This has been fixed.
-
 ## Examples

 ??? example
@@ -46,17 +46,6 @@ for (auto& [key, val] : j_object.items())
 }
 ```

-If you need to name the type of the dereferenced element explicitly (e.g., to write a standalone function that
-takes it as a parameter, or to use `items()` with `std::for_each`), use `decltype`:
-
-```cpp
-using element_type = decltype(*j_object.items().begin());
-```
-
-The per-element type (`iteration_proxy_value`) lives in the library's internal `detail` namespace and is
-intentionally unspecified as a stable, named type -- `decltype` is the supported way to obtain it, but its exact
-name/definition may change between versions.
-
 ## Return value

 iteration proxy object wrapping the current value with an interface to use in range-based for loops
@@ -63,8 +63,7 @@ behavior:
  object will agree on the name-value mappings.
 - When the names within an object are not unique, it is unspecified which one of the values for a given key will be
  chosen. For instance, `#!json {"key": 2, "key": 1}` could be equal to either `#!json {"key": 1}` or
-  `#!json {"key": 2}`. To reject duplicate keys instead of silently resolving them one way or another, see
-  [this parsing recipe](../../features/parsing/parser_callbacks.md#recipe-rejecting-duplicate-object-keys).
+  `#!json {"key": 2}`.
 - Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see
  [`dump`](dump.md)) in this order. For instance, `#!json {"b": 1, "a": 2}` and `#!json {"a": 2, "b": 1}` will be stored
  and serialized as `#!json {"a": 2, "b": 1}`.
@@ -94,15 +93,6 @@ alphabetical order as `std::map` with `std::less` is used by default. Please not
 [RFC 8259](https://tools.ietf.org/html/rfc8259), because any order implements the specified "unordered" nature of JSON
 objects.

-#### Cross-`basic_json` conversion requirements
-
-When converting an object from one `basic_json` specialization to another via the
-[converting constructor](basic_json.md#overload-4), the target `object_t`'s `key_type` must be
-directly constructible from the source `basic_json`'s `string_t` type (or more generally, from the
-source object's key type). If this requirement is not met, the conversion does not fail; instead,
-the object is silently converted as an array of key-value pairs, which is incorrect. See
-[issue #3425](https://github.com/nlohmann/json/issues/3425) for details and an example.
-
 ## Examples

 ??? example
@@ -124,15 +124,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
      filled with `#!json null`.
    - The special value `-` is treated as a synonym for the index past the end.

-    !!! note "Creating intermediate levels that don't exist yet"
-
-        When the JSON pointer traverses intermediate levels that don't exist at all yet (not just a missing
-        leaf), each missing level is created as an array or an object depending on whether the corresponding
-        pointer token parses as a non-negative integer: a numeric token creates an array, a non-numeric token
-        creates an object. For example, on an initially `#!json null` value, `/foo/0/0/0` creates nested arrays,
-        while `/foo/one/one/one` creates nested objects. This is not specified by the JSON Pointer RFC; it is
-        this library's own, intentional disambiguation rule. See also [JSON Pointer](../../features/json_pointer.md).
-
 ## Examples

 ??? example "Example: (1) access specified array element"
@@ -260,6 +251,5 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0.
 2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3)
   in version 3.11.0.
-3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
-   already supported by [`at`](at.md), [`value`](value.md), [`find`](find.md), and other lookup functions.
+3. Added in version 3.11.0.
 4. Added in version 2.0.0.
@@ -19,8 +19,10 @@ class basic_json {
 };
 ```

-1. Compares two JSON values for inequality. Returns `#!cpp !(lhs == rhs)` (until C++20) or `#!cpp !(*this == rhs)` (since C++20).
-    - This means the comparison is simply the logical negation of `operator==`, including for special values like `NaN` and `discarded`.
+1. Compares two JSON values for inequality according to the following rules:
+    - The comparison always yields `#!cpp false` if (1) either operand is discarded, or (2) either operand is `NaN` and
+      the other operand is either `NaN` or any other number.
+    - Otherwise, returns the result of `#!cpp !(lhs == rhs)` (until C++20) or `#!cpp !(*this == rhs)` (since C++20).

 2. Compares a JSON value and a scalar or a scalar and a JSON value for inequality by converting the scalar to a JSON
   value and comparing both JSON values according to 1.
@@ -52,12 +54,13 @@ Linear.

 ## Notes

-!!! note "Comparing `NaN` and `discarded`"
+!!! note "Comparing `NaN`"

-    Since `operator!=` is defined as `!(a == b)`, the behavior for special values follows that of `operator==`:
-    
-    - For `NaN` values: `NaN == NaN` yields `#!cpp false`, so `NaN != NaN` yields `#!cpp true`.
-    - For `discarded` values: `discarded == x` yields `#!cpp false` for any `x`, so `discarded != x` yields `#!cpp true`.
+    `NaN` values are unordered within the domain of numbers.
+    The following comparisons all yield `#!cpp false`:
+      1. Comparing a `NaN` with itself.
+      2. Comparing a `NaN` with another `NaN`.
+      3. Comparing a `NaN` and any other number.

 ## Examples

@@ -91,7 +94,5 @@ Linear.

 ## Version history

-1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove 
-   special-casing for `NaN` and `discarded` values; `operator!=` now consistently means `!(a == b)`.
-2. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove
-   special-casing for `NaN` and `discarded` values; `operator!=` now consistently means `!(a == b)`.
+1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0.
+2. Added in version 1.0.0. Added C++20 member functions in version 3.11.0.
@@ -34,8 +34,7 @@ static basic_json parse(IteratorType first, IteratorType last,
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters (throws if null)
    - a `std::string`
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.

 `IteratorType`
 :   a compatible iterator type, for instance.
@@ -236,8 +235,7 @@ Invalid Unicode escapes and unpaired surrogates in the input are reported as
 - Overload for contiguous containers (1) added in version 2.0.3.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
 - Changed [runtime assertion](../../features/assertions.md) in case of `FILE*` null pointers to exception in version 3.12.0.
- Added `ignore_trailing_commas` in version 3.13.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
+- Added `ignore_trailing_commas` in version 3.12.x.

 !!! warning "Deprecation"

@@ -74,4 +74,4 @@ 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.
+  target location has a non-object/non-array parent in version 3.12.x.
@@ -71,4 +71,4 @@ 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.
+  target location has a non-object/non-array parent in version 3.12.x.
@@ -39,8 +39,8 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
-    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
-      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
+    - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of
+      iterators.

 `IteratorType`
 :   a compatible iterator type for overload (2); a pair of character iterators whose `value_type` is an integral type
@@ -126,8 +126,7 @@ A UTF-8 byte order mark is silently ignored.

 - Added in version 3.2.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
- Added `ignore_trailing_commas` in version 3.13.0.
- Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
+- Added `ignore_trailing_commas` in version 3.12.x.

 !!! warning "Deprecation"

@@ -54,4 +54,4 @@ provides `<format>`, controlled by the [`JSON_HAS_STD_FORMAT`](../macros/json_ha

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -18,11 +18,6 @@ JSON class into byte-sized characters during deserialization.
 :   the container to store strings (e.g., `std::string`). Note this container is used for keys/names in objects, see
    [object_t](object_t.md).

-    `StringType` must have a `char`-compatible `value_type`: the library relies on UTF-8/`char`-based storage and
-    processing internally, so `std::wstring`, `std::u16string`, and `std::u32string` are **not** valid choices for
-    `StringType`. To work with wide-character data, convert it to/from UTF-8 at the boundary instead -- see the
-    FAQ's [wide string handling](../../home/faq.md#wide-string-handling) section for a conversion recipe.
-
 ## Notes

 #### Default type
@@ -50,15 +45,6 @@ This implementation is interoperable as it does compare strings code unit by cod
 String values are stored as pointers in a `basic_json` type. That is, for any access to string values, a pointer of type
 `string_t*` must be dereferenced.

-#### Cross-`basic_json` conversion requirements
-
-When converting a string value from one `basic_json` specialization to another via the
-[converting constructor](basic_json.md#overload-4), the target `string_t` must be directly
-constructible from the source `basic_json`'s `string_t` type. If this requirement is not met, the
-conversion does not fail; instead, the string is silently converted as an array of character codes,
-which is incorrect. See [issue #3425](https://github.com/nlohmann/json/issues/3425) for details
-and an example.
-
 ## Examples

 ??? example
@@ -21,12 +21,6 @@ a string representation of the type ([`value_t`](value_t.md)):
 | array                                              | `"array"`     |
 | binary                                             | `"binary"`    |
 | discarded                                          | `"discarded"` |
-| invalid (corrupted value)                          | `"invalid"`   |
-
-!!! note "The \"invalid\" type"
-
-    The `"invalid"` return value indicates a corrupted JSON value — this can occur if an enum value falls outside the
-    range of valid `value_t` values. This is useful for diagnosing data corruption or internal errors.

 ## Exception safety

@@ -58,4 +52,3 @@ Constant.
 - Part of the public API version since 2.1.0.
 - Changed return value to `const char*` and added `noexcept` in version 3.0.0.
 - Added support for binary type in version 3.8.0.
- Added `"invalid"` return value for corrupted JSON values in version 3.13.0.
@@ -17,8 +17,6 @@ ValueType value(const json_pointer& ptr,
                const ValueType& default_value) const;
 ```

-This is equivalent to Python's `dict.get(key, default)`.
-
 1. Returns either a copy of an object's element at the specified key `key` or a given default value if no element with
   key `key` exists.
   
@@ -186,6 +184,4 @@ changes to any JSON value.

 1. Added in version 1.0.0. Changed parameter `default_value` type from `const ValueType&` to `ValueType&&` in version 3.11.0.
 2. Added in version 3.11.0. Made `ValueType` the first template parameter in version 3.11.2.
-3. Added in version 2.0.2. Extended to work with arrays in version 3.13.0, including fixing an issue where resolving
-   `ptr` through an array unexpectedly threw `out_of_range` instead of returning the resolved element (or
-   `default_value`, as documented).
+3. Added in version 2.0.2. Extended to work with arrays in version 3.12.x.
@@ -36,4 +36,4 @@ Constant.

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -32,4 +32,4 @@ Linear in the number of reference tokens in the `json_pointer`.

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -35,4 +35,4 @@ Linear in the number of reference tokens in the `json_pointer`.

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -92,4 +92,4 @@ The default value is `0` (disabled — existing behavior is preserved).

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -44,4 +44,4 @@ The default value is detected based on preprocessor macros such as `#!cpp __cplu

 - Added in version 3.10.5.
 - Added `JSON_HAS_CPP_23` in version 3.12.0.
- Added `JSON_HAS_CPP_26` in version 3.13.0.
+- Added `JSON_HAS_CPP_26` in version 3.12.x.
@@ -19,20 +19,6 @@ The default value is detected based on the preprocessor macros `#!cpp __cpp_lib_
 `#!cpp __cpp_lib_experimental_filesystem`, `#!cpp __has_include(<filesystem>)`, or
 `#!cpp __has_include(<experimental/filesystem>)`.

-!!! info "Known compiler/stdlib exclusions"
-
-    Even when the feature-test macro indicates filesystem support is available, the library disables it on the following broken toolchains:
-    
-    - **MinGW + GCC 8** — disabled entirely (broken `std::filesystem` implementation; [MinGW-w64 bug 737](https://sourceforge.net/p/mingw-w64/bugs/737/))
-    - **GCC (non-Clang) < 8** — disabled (no filesystem support)
-    - **Clang < 7** — disabled (no filesystem support)
-    - **MSVC < 19.14** — disabled (no filesystem support)
-    - **iOS < 13** — disabled (no filesystem support)
-    - **macOS < Catalina (10.15)** — disabled (no filesystem support)
-    
-    If `JSON_HAS_FILESYSTEM` or `JSON_HAS_EXPERIMENTAL_FILESYSTEM` is `0` despite `__cpp_lib_filesystem` being defined, one
-    of the exclusions above likely applies to your toolchain.
-
 ## Notes

 - Note that older compilers or older versions of libstdc++ also require the library `stdc++fs` to be linked to for
@@ -13,20 +13,6 @@ The default value is detected based on the preprocessor macro `#!cpp __cpp_lib_r

 When the macro is not defined, the library will define it to its default value.

-!!! info "Known compiler/stdlib exclusions"
-
-    Even when the feature-test macro `__cpp_lib_ranges` indicates ranges support is available, the library disables it on
-    the following incomplete or broken toolchains:
-    
-    - **GCC 11.1.0** — disabled (the shipped `<ranges>` header has a syntax error; [issue #4440](https://github.com/nlohmann/json/issues/4440))
-    - **libstdc++ < 11** — disabled (incomplete C++20 ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
-    - **Clang < 16 with libstdc++** — disabled (incomplete ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
-    - **libc++ < 160000** — disabled (incomplete C++20 ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
-    - **nvcc (CUDA) 12.0.x and 12.1.x** — disabled (the `enable_borrowed_range` variable-template syntax triggers a parse error
-      under these two toolkit versions; fixed in CUDA 12.2; [issue #3907](https://github.com/nlohmann/json/issues/3907))
-    
-    If `JSON_HAS_RANGES` is `0` despite `__cpp_lib_ranges` being defined, one of the exclusions above likely applies to your toolchain.
-
 ## Examples

 ??? example
@@ -38,4 +38,4 @@ When the macro is not defined, the library will define it to its default value.

 ## Version history

- Added in version 3.13.0.
+- Added in version 3.12.x.
@@ -62,9 +62,6 @@ See the examples below for the concrete generated code.

    - The current implementation is limited to at most 63 member variables. If you want to serialize/deserialize types
      with more than 63 member variables, you need to define the `to_json`/`from_json` functions manually.
-    - These macros always produce object-style (named-key) JSON, one key per member. There is no macro variant
-      that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
-      hand, building/reading a `json::array()` of the members in order.

 ## Examples

@@ -63,9 +63,6 @@ See the examples below for the concrete generated code.

    - The current implementation is limited to at most 63 member variables. If you want to serialize/deserialize types
      with more than 63 member variables, you need to define the `to_json`/`from_json` functions manually.
-    - These macros always produce object-style (named-key) JSON, one key per member. There is no macro variant
-      that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
-      hand, building/reading a `json::array()` of the members in order.

 ## Examples

@@ -75,4 +75,4 @@ For further information please refer to the corresponding macros without `WITH_N

 ## Version history

-1. Added in version 3.13.0.
+1. Added in version 3.12.x.
@@ -102,4 +102,4 @@ inline void from_json(const BasicJsonType& j, type& e);

 ## Version history

-Added in version 3.13.0.
+Added in version 3.12.x.
@@ -33,18 +33,6 @@ A UTF-8 byte order mark is silently ignored.
 Invalid Unicode escapes and unpaired surrogates in the input are reported as
 [`parse_error.101`](../home/exceptions.md#jsonexceptionparse_error101) with a detailed message.

-`operator>>` parses exactly one JSON value and leaves the stream positioned right after it, so it can be called
-repeatedly to read a sequence of concatenated JSON values from the same stream:
-
-```cpp
-json j1, j2;
-input >> j1;  // parses the first value, stream now positioned right after it
-input >> j2;  // parses the next value
-```
-
-Note this does **not** work for [JSON Lines](../features/parsing/json_lines.md) (newline-delimited JSON) input --
-see that page for why and for the recommended alternative.
-
 !!! warning "Deprecation"

    This function replaces function `#!cpp std::istream& operator<<(basic_json& j, std::istream& i)` which has
@@ -64,4 +64,4 @@ Linear.

 - Added in version 1.0.0.
 - Moved to namespace `nlohmann::literals::json_literals` in 3.11.0.
- Added `char8_t*` overload in 3.13.0.
+- Added `char8_t*` overload in 3.12.x.
@@ -63,4 +63,4 @@ Linear.

 - Added in version 2.0.0.
 - Moved to namespace `nlohmann::literals::json_literals` in 3.11.0.
- Added `char8_t*` overload in 3.13.0.
+- Added `char8_t*` overload in 3.12.x.
@@ -10,10 +10,6 @@ violations will result in a failed build.

    Any compiler with complete C++11 support can compile the library without warnings.

-Note: C++20 modules support may hit compiler-specific issues not covered by the general compiler matrix below. See [Modules](../features/modules.md#known-issues) for known issues and workarounds.
-
-Note: Some modern features (like C++20 ranges or filesystem support) may be disabled on specific broken or incomplete toolchains even when standard feature-test macros indicate support. See [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) and [`JSON_HAS_FILESYSTEM`](../api/macros/json_has_filesystem.md) for details on known exclusions.
-
 - [x] The library is compiled with 50+ different C++ compilers with different operating systems and platforms,
  including the oldest versions known to compile the library.

@@ -66,14 +62,12 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | Clang 20.1.1                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 20.1.8 with GNU-like command-line      | x86_64       | Windows Server 2022 (Build 20348) | GitHub    |
        | Clang 21.1.8                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | CUDA 11.8.0 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
-        | CUDA 12.1.1 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
-        | CUDA 12.6.3 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
+        | CUDA 11.0.221 (nvcc)                         | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
        | Emscripten 4.0.6                             | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | GNU 4.8.5                                    | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
-        | GNU 4.9.3                                    | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
-        | GNU 5.5.0                                    | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
-        | GNU 6.4.0                                    | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
+        | GNU 4.8.5                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 4.9.3                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 5.5.0                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 6.4.0                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 7.5.0                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 8.5.0                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 9.3.0                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
@@ -90,7 +84,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | GNU 15.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 16.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 16.1.0                                   | arm64        | Linux 6.1.100                     | Cirrus CI |
-        | icpc (ICC) 2021.10.0 20230609                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
+        | icpc (ICC) 2021.5.0 20211109                 | x86_64       | Ubuntu 20.04.3 LTS                | GitHub    |
        | icpx (Intel oneAPI DPC++/C++) 2025.3.2       | x86_64       | Ubuntu 24.04 LTS                  | GitHub    |
        | nvc++ (NVIDIA HPC SDK) 25.5-0                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | MSVC 19.0.24241.7                            | x86          | Windows 8.1                       | AppVeyor  |
@@ -1,61 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <stdexcept>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-using json = nlohmann::json;
-
-json parse_strict(const std::string& input)
-{
-    // one key set per nesting depth, reused across sibling objects
-    std::vector<std::unordered_set<std::string>> keys;
-
-    auto reject_duplicate_keys = [&](int depth, json::parse_event_t event, json & parsed)
-    {
-        if (event == json::parse_event_t::object_start)
-        {
-            // keys of this object are reported at depth+1 (see the event table above)
-            const auto child_depth = static_cast<std::size_t>(depth) + 1;
-            if (keys.size() <= child_depth)
-            {
-                keys.resize(child_depth + 1);
-            }
-            keys[child_depth].clear();
-            return true;
-        }
-
-        if (event == json::parse_event_t::key)
-        {
-            auto& seen = keys[static_cast<std::size_t>(depth)];
-            const auto& key = parsed.get_ref<const std::string&>();
-            if (!seen.insert(key).second)
-            {
-                throw std::runtime_error("duplicate JSON object key: " + key);
-            }
-            return true;
-        }
-
-        return true;
-    };
-
-    return json::parse(input, reject_duplicate_keys);
-}
-
-int main()
-{
-    // parsing succeeds when all keys are unique
-    json j = parse_strict(R"({"one": 1, "two": 2})");
-    std::cout << j << '\n';
-
-    // parsing throws when a key is repeated
-    try
-    {
-        parse_strict(R"({"one": 1, "one": 2})");
-    }
-    catch (const std::exception& e)
-    {
-        std::cout << e.what() << '\n';
-    }
-}
@@ -1,2 +0,0 @@
-{"one":1,"two":2}
-duplicate JSON object key: one
@@ -180,49 +180,6 @@ For _derived_ classes and structs, use the following macros
    }
    ```

-!!! warning "Overriding conversions for natively-supported types"
-
-    The library already provides built-in `to_json`/`from_json` conversions for STL containers such as
-    `std::vector`, `std::array`, and `std::map`. Defining your own free-function `to_json`/`from_json` overload
-    for one of these container types directly (instead of for your own type) can conflict with the built-in
-    overload during overload resolution, producing compiler errors ("no matching overloaded function",
-    "call is ambiguous") that vary by compiler and library version. If you need different conversion behavior
-    for a container type the library already handles, wrap it in your own type (or use `adl_serializer`
-    specialization, as shown [above](#how-do-i-convert-third-party-types) for `boost::optional`) instead of
-    trying to re-specialize `to_json`/`from_json` for the container type itself.
-
-!!! warning "Raw C-style arrays"
-
-    Members declared as raw C-style arrays (e.g., `char buf[1024]`) do not round-trip safely through
-    `NLOHMANN_DEFINE_TYPE_*` macros or the default (de)serializers: `to_json` serializes any `char` array as a
-    JSON *string* (matching the `std::string`-constructible overload), but the `from_json` overload for
-    fixed-size arrays expects a JSON *array* and iterates it element-wise, which fails with a `type_error` when
-    given a string. Use `std::string`, `std::array<char, N>`, or a manually written `to_json`/`from_json` pair
-    for such members instead.
-
-!!! note "Macros and `nlohmann::ordered_json`"
-
-    The `NLOHMANN_DEFINE_TYPE_*`/`NLOHMANN_DEFINE_DERIVED_TYPE_*` macros are generic over any `basic_json`
-    specialization, including `nlohmann::ordered_json`. Simply use `ordered_json` as the target type and members
-    are serialized in declaration order -- no separate macro or extra code is needed.
-
-    ```cpp
-    namespace ns {
-        NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
-    }
-
-    ns::person p{"Ned Flanders", "744 Evergreen Terrace", 60};
-    nlohmann::ordered_json j = p; // keys appear in declaration order: name, address, age
-    ```
-
-!!! note "No macro for non-default-constructible types"
-
-    There is currently no `NLOHMANN_DEFINE_TYPE_*`-style macro for types that are not
-    [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). This is not an
-    intentional omission of documentation -- no such macro exists yet; see
-    [How can I use `get()` for non-default constructible/non-copyable types?](#how-can-i-use-get-for-non-default-constructiblenon-copyable-types)
-    for the manual pattern to use instead.
-
 ## How do I convert third-party types?

 This requires a bit more advanced technique. But first, let us see how this conversion mechanism works:
@@ -313,49 +270,6 @@ namespace nlohmann {
 }
 ```

-## Why can't I convert to/from `std::any`?
-
-`std::any` is intentionally excluded from `get<T>()`/generic conversion support, so `get<std::any>()` and
-containers like `std::map<std::string, std::any>` fail to compile by design -- there is no way to know, from a
-`json` value alone, which concrete type to store inside the `std::any`. To work with heterogeneous JSON values,
-dispatch on the value's type manually and construct the `std::any` (or extract from it) yourself:
-
-```cpp
-std::any value_to_any(const json& j) {
-    if (j.is_boolean())      { return j.get<bool>(); }
-    if (j.is_number_integer()) { return j.get<int>(); }
-    if (j.is_number_float()) { return j.get<double>(); }
-    if (j.is_string())       { return j.get<std::string>(); }
-    // ... handle other types (arrays, objects) as needed for your use case
-    return {};
-}
-
-json any_to_json(const std::any& a) {
-    if (a.type() == typeid(bool))        { return std::any_cast<bool>(a); }
-    if (a.type() == typeid(int))         { return std::any_cast<int>(a); }
-    if (a.type() == typeid(double))      { return std::any_cast<double>(a); }
-    if (a.type() == typeid(std::string)) { return std::any_cast<std::string>(a); }
-    return nullptr;
-}
-```
-
-## Why does serializing a `std::map`/`std::unordered_map` with non-string keys produce an array?
-
-A `std::map`/`std::unordered_map` whose key type is not string-like (e.g., `std::map<int, std::string>`) is
-serialized as a JSON *array* of 2-element `[key, value]` arrays, not as a JSON object -- JSON object keys must be
-strings, so the library cannot represent an integer-keyed map as an object.
-
-```cpp
-std::map<int, std::string> m{{1, "one"}, {2, "two"}};
-json j = m;
-// j is [[1,"one"],[2,"two"]], not {"1":"one","2":"two"}
-```
-
-## Why does `std::wstring` convert or dump incorrectly?
-
-The library assumes UTF-8 encoding internally, so `std::wstring` is not supported out of the box -- see the FAQ
-entry on [wide string handling](../home/faq.md#wide-string-handling) for why, and for a UTF-8 conversion recipe.
-
 ## Can I write my own serializer? (Advanced use)

 Yes. You might want to take a look at [`unit-udt.cpp`](https://github.com/nlohmann/json/blob/develop/tests/src/unit-udt.cpp) in the test suite, to see a few examples.
@@ -66,15 +66,7 @@ see "binary" cells in the table above.

 !!! info "NaN/infinity handling"

-    `NaN`, `Infinity`, and `-Infinity` are serialized as a CBOR half-precision float (type 0xF9, 3 bytes total):
-    `NaN` as `0xF9 0x7E 0x00`, `Infinity` as `0xF9 0x7C 0x00`, and `-Infinity` as `0xF9 0xFC 0x00`. This behavior
-    differs from the normal JSON serialization which serializes NaN or Infinity to `null`.
-
-!!! note
-
-    Prior to version 3.13.0, NaN and Infinity were instead serialized as a CBOR double-precision float (type 0xFB,
-    9 bytes total), because the check used to select a smaller encoding compared magnitudes with NaN, which is
-    always `false` and caused the intended half-precision path to be skipped.
+    If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the normal JSON serialization which serializes NaN or Infinity to `null`.

 !!! info "Unused CBOR types"

@@ -168,13 +160,6 @@ The library maps CBOR types to JSON value types as follows:
     - simple values (0xE0..0xF3, 0xF8)
     - undefined (0xF7)

-!!! warning "Negative integer overflow"
-
-    CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
-    result to fit into `number_integer_t` (`std::int64_t` by default), parsing fails with a
-    [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) exception rather than overflowing
-    silently.
-
 !!! warning "Object keys"

    CBOR allows map keys of any type, whereas JSON only allows strings as keys in object values. Therefore, CBOR maps with keys other than UTF-8 strings are rejected.
@@ -67,15 +67,8 @@ specification:

 !!! info "NaN/infinity handling"

-    `NaN`, `Infinity`, and `-Infinity` are serialized as a MessagePack float 32 (type 0xCA, 5 bytes total),
-    regardless of magnitude, in contrast to the [dump](../../api/basic_json/dump.md) function which serializes NaN
-    or Infinity to `null`.
-
-!!! note
-
-    Prior to version 3.13.0, NaN and Infinity were instead serialized as a MessagePack float 64 (type 0xCB, 9 bytes
-    total), because the check used to select the smaller float 32 encoding compared magnitudes with NaN, which is
-    always `false` and caused the float 32 path to be skipped.
+    If NaN or Infinity are stored inside a JSON number, they are serialized properly in contrast to the
+    [dump](../../api/basic_json/dump.md) function which serializes NaN or Infinity to `null`.

 ??? example

@@ -11,7 +11,7 @@ This library does not support comments *by default*. It does so for three reason

 3. It is dangerous for interoperability if some libraries add comment support while others do not. Please check [The Harmful Consequences of the Robustness Principle](https://tools.ietf.org/html/draft-iab-protocol-maintenance-01) on this.

-However, you can set parameter `ignore_comments` to `#!cpp true` in the [`parse`](../api/basic_json/parse.md) function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace. Combined with `ignore_trailing_commas` (also a `parse` parameter), this covers what is commonly referred to as **JSONC** (JSON with Comments, as used e.g. by Visual Studio Code's `.jsonc` files) -- comments and trailing commas, nothing more. This is a different, smaller extension than [JSON5](https://json5.org), which additionally allows unquoted keys, single-quoted strings, and other syntax changes that this library does not support.
+However, you can set parameter `ignore_comments` to `#!cpp true` in the [`parse`](../api/basic_json/parse.md) function to ignore `//` or `/* */` comments. Comments will then be treated as whitespace.

 For more information, see [JSON With Commas and Comments (JWCC)](https://nigeltao.github.io/blog/2021/json-with-commas-comments.html).

@@ -66,67 +66,6 @@ which forces the explicit `get` form and can catch unintended conversions at com
    floating-point value as an integer truncates it, and narrowing conversions may overflow. See
    [number conversion](types/number_handling.md#number-conversion) for details and how to guard against it.

-!!! warning "std::optional direct construction from JSON null throws"
-
-    Constructing or assigning `std::optional<T>` directly from a JSON value does not correctly produce
-    `std::nullopt` for a JSON `null`:
-
-    ```cpp
-    json j_null;
-    std::optional<std::string> opt = j_null;  // ❌ throws type_error 302
-    ```
-
-    This is due to C++ language rules: `std::optional<T>` has its own converting constructor that is chosen over
-    `basic_json::operator T()` when both are viable. Use `get<std::optional<T>>()` or `get_to()` instead:
-
-    ```cpp
-    auto opt = j_null.get<std::optional<std::string>>();  // ✅ std::nullopt
-    j_null.get_to(opt);                                     // ✅ std::nullopt
-    ```
-
-!!! warning "`static_cast` and `get<std::optional<T>>()` are not guaranteed equivalent"
-
-    `operator ValueType()` (used by `static_cast` and implicit conversions) intentionally excludes
-    `std::optional<T>` from delegating to `get<T>()`, to avoid a constructor ambiguity with
-    `std::optional<T>`'s own converting constructor from `basic_json`. As a result,
-    `static_cast<std::optional<T>>(json_value)` goes through `std::optional<T>`'s own converting
-    constructor rather than through `get<std::optional<T>>()`, which can behave differently -- for example,
-    with a custom `adl_serializer<std::optional<T>>` specialization. Prefer `get<std::optional<T>>()`/`get_to()`
-    over `static_cast` for optional types.
-
-!!! warning "Converting to a fixed-size `std::array` does not check length"
-
-    Converting a JSON array to `#!cpp std::array<T, N>` does not check that the JSON array's size matches `N`:
-    if the JSON array is longer, the extra elements are silently dropped; if it is shorter, the remaining
-    `std::array` elements are left default-constructed. No exception is thrown in either case.
-
-    ```cpp
-    json j = {1, 2, 3, 4, 5};
-    auto a = j.get<std::array<int, 3>>();  // {1, 2, 3} -- elements 4 and 5 silently dropped
-    ```
-
-## Omitting a field when serializing `std::optional`
-
-By default, `to_json` for `std::optional<T>` writes either the value or `#!json null` -- there is no built-in way
-to make a field disappear from the serialized object entirely when the `std::optional` is `std::nullopt`. Because
-a specialization of `adl_serializer<std::optional<T>>` only controls how the *value* is converted (it cannot
-prevent the containing object's `to_json` from inserting the key in the first place), omission has to be
-implemented in the *containing* type's `to_json`:
-
-```cpp
-struct person {
-    std::string name;
-    std::optional<int> age;
-};
-
-void to_json(json& j, const person& p) {
-    j = json{{"name", p.name}};
-    if (p.age) {
-        j["age"] = *p.age;  // key is only inserted when the optional has a value
-    }
-}
-```
-
 ## Putting values in

 The reverse direction works the same way: assigning or constructing a `json` from a C++ value converts it to JSON.
@@ -4,8 +4,7 @@

 In many situations, such as configuration files, missing values are not exceptional, but may be treated as if a default
 value was present. For this case, use [`value(key, default_value)`](../../api/basic_json/value.md) which takes the key
-you want to access and a default value in case there is no value stored with that key. This is equivalent to Python's
-`dict.get(key, default)`.
+you want to access and a default value in case there is no value stored with that key.

 ## Example

@@ -102,20 +102,6 @@ that the passed index is the new maximal index. Intermediate values are filled w
    `operator[]` can only be used with objects (with a string argument) or with arrays (with a numeric argument). For
    other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error305) is thrown.

-## Performance: reserving array capacity
-
-There is no public `reserve(count)` member on `basic_json` for pre-allocating array capacity. If you are building
-a large array incrementally (e.g., via repeated `push_back()`) and know its final size ahead of time, you can
-reserve capacity via `get_ref()` to access the underlying `array_t` directly:
-
-```cpp
-json j = json::array();
-j.get_ref<json::array_t&>().reserve(1000);
-for (int i = 0; i < 1000; ++i) {
-    j.push_back(i);
-}
-```
-
 ## Summary

 | scenario                          | non-const value                                                                                                                                      | const value                                                                 |
@@ -77,11 +77,6 @@ auto val2 = j.at(json::json_pointer("/nested/three/1"));    // false
 auto val3 = j.value(json::json_pointer("/nested/four"), 0); // 0
 ```

-!!! note "Creating intermediate levels that don't exist"
-
-    See the [`operator[]` notes](../api/basic_json/operator%5B%5D.md#return-value) for how array vs. object is
-    decided when a pointer creates intermediate levels that don't exist yet.
-
 ## Flatten / unflatten

 The library implements a function [`flatten`](../api/basic_json/flatten.md) to convert any JSON document into a JSON
@@ -27,7 +27,6 @@ json data = json::parse(f);
 It should be noted that as modules do not export macros, the `nlohmann.json` module will not export any macros.

 ## Exported symbols
-
 Only the following symbols are exported from `nlohmann.json`:

 - `nlohmann::adl_serializer`
@@ -39,21 +38,3 @@ Only the following symbols are exported from `nlohmann.json`:
 - `nlohmann::to_string`
 - `nlohmann::literals::json_literals::operator""_json`
 - `nlohmann::literals::json_literals::operator""_json_pointer`
-
-Additionally, the following `nlohmann::detail` symbols are exported, solely to work around an MSVC compilation issue
-([#3970](https://github.com/nlohmann/json/issues/3970)). They are implementation details, not part of the public API,
-and should not be used directly:
-
- `nlohmann::detail::json_sax_dom_callback_parser`
- `nlohmann::detail::unknown_size`
-
-## Known issues
-
-C++20 modules support is exercised in CI against current GCC and Clang on Ubuntu, and the default MSVC toolset on Windows Server 2022 — there is no documented minimum compiler version, unlike feature-test-macro-gated features such as [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md).
-
-!!! info "Known compiler issues"
-
-    - **GCC** may emit "redefinition" errors when `#include <nlohmann/json.hpp>` appears in a module preamble together with other imports. This is an upstream GCC bug, not yet resolved as of GCC 16. Workarounds: include `nlohmann/json.hpp` before other `#include`s, use `import nlohmann.json;` instead, or upgrade GCC. ([issue #5103](https://github.com/nlohmann/json/issues/5103))
-    - **MSVC** could fail with `C2039: 'json_sax_dom_callback_parser' is not a member of ... detail`; fixed by exporting the required internal symbols from `json.cppm` (see [Exported symbols](#exported-symbols) above). ([issue #3970](https://github.com/nlohmann/json/issues/3970))
-
-    If you hit a different module-related build failure, search [existing issues](https://github.com/nlohmann/json/issues?q=is%3Aissue+modules) before filing a new one.
@@ -47,6 +47,3 @@ JSON Lines input with more than one value is treated as invalid JSON by the [`pa
    ```
    
    with a JSON Lines input does not work, because the parser will try to parse one value after the last one.
-
-    This is different from parsing a stream of *concatenated* (non-newline-delimited) JSON values, for which
-    `operator>>` does work -- see its [notes](../../api/operator_gtgt.md#notes) for details.
@@ -58,14 +58,6 @@ table describes the values of the parameters `depth`, `event`, and `parsed`.
    | `array_end`    | 1     | `#!json [52.519444,13.406667]` |
    | `object_end`   | 0     | `#!json {"location":[52.519444,13.406667],"name":"Berlin"}` |

-!!! note "No built-in nesting depth limit"
-
-    The library has no built-in limit on recursion/nesting depth while parsing. A parser callback can only
-    *discard* content it has already parsed (by returning `#!c false`); it cannot make parsing fail once a
-    nesting limit is exceeded partway through reading a deeply nested value. If you need to reject over-deep
-    untrusted input outright, track `depth` in a callback and `throw` from it once your limit is exceeded (a
-    thrown exception propagates out of `parse()` as usual).
-
 ## Return value

 Discarding a value (i.e., returning `#!c false`) has different effects depending on the context in which the function
@@ -89,82 +81,3 @@ was called:
    ```json
    --8<-- "examples/parse__string__parser_callback_t.output"
    ```
-
-## Recipe: rejecting duplicate object keys
-
-The JSON specification leaves the handling of objects with repeated keys up to the implementation. As described in
-[`object_t`](../../api/basic_json/object_t.md#behavior), it is unspecified which value for a repeated key ends up in
-the resulting `#!c json` value -- once parsing has produced that value, the duplicate is already gone, because object
-storage maps each key to a single value. If duplicate keys should instead be treated as an error, a parser callback
-can detect them while the object is still being read, before that ambiguity ever applies.
-
-??? example
-
-    ```cpp
-    --8<-- "examples/reject_duplicate_keys.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/reject_duplicate_keys.output"
-    ```
-
-This approach has two limitations:
-
- The depth-indexed bookkeeping must account for the fact that `object_start` reports the depth of the *parent* of
-  the object, while the `key` events inside that object are reported one depth deeper (see the event table above);
-  it is easy to get this off by one for nested objects.
- The thrown exception cannot carry a `parse_error`-style byte offset, because position tracking only exists inside
-  the parser and lexer, not at the callback layer.
-
-For strict validation with precise error positions, implementing a [SAX interface](sax_interface.md) instead gives
-access to the parser's position information directly.
-
-## Recipe: streaming a large homogeneous array
-
-A common use case is a huge top-level array of many similarly-shaped objects, too large to hold entirely in
-memory as a `#!c json` value. A parser callback can hand off each completed element to a user function and then
-discard it, so memory usage stays bounded by a single element (plus the not-yet-parsed tail of the input) rather
-than the whole document. Since the top-level array's `array_start`/`array_end` are reported at `depth == 0` (its
-parent is the document root), the object elements it contains are reported at `depth == 1`:
-
-??? example
-
-    ```cpp
-    std::ifstream input("large_array.json");
-
-    auto callback = [](int depth, json::parse_event_t event, json& parsed) -> bool {
-        if (depth == 1 && event == json::parse_event_t::object_end) {
-            handle_element(parsed); // process the element, e.g. write it elsewhere
-            return false;           // discard it -- frees its memory before the next one is parsed
-        }
-        return true; // keep everything else, including the (by then empty) top-level array
-    };
-
-    json::parse(input, callback);
-    ```
-
-If the array's elements are scalars or nested arrays instead of objects, check for `parse_event_t::value` or
-`parse_event_t::array_end` at `depth == 1` instead. The same approach works for a top-level *object* of many
-homogeneous values by checking `object_end`/`value` events at `depth == 1` there too.
-
-## Recipe: max nesting depth via a callback
-
-Since there is no built-in nesting-depth limit (see the note above), a callback can enforce one manually by
-tracking the maximum `depth` seen and throwing once it is exceeded:
-
-??? example
-
-    ```cpp
-    constexpr int max_depth = 32;
-
-    auto callback = [](int depth, json::parse_event_t /*event*/, json& /*parsed*/) -> bool {
-        if (depth > max_depth) {
-            throw std::runtime_error("maximum nesting depth exceeded");
-        }
-        return true;
-    };
-
-    json::parse(input, callback);
-    ```
@@ -131,7 +131,7 @@ std::map<
 The choice of `object_t` influences the behavior of the JSON class. With the default type, objects have the following behavior:

 - When all names are unique, objects will be interoperable in the sense that all software implementations receiving that object will agree on the name-value mappings.
- When the names within an object are not unique, it is unspecified which one of the values for a given key will be chosen. For instance, `#!json {"key": 2, "key": 1}` could be equal to either `#!json {"key": 1}` or `#!json {"key": 2}`. To reject duplicate keys instead of silently resolving them one way or another, see [this parsing recipe](../parsing/parser_callbacks.md#recipe-rejecting-duplicate-object-keys).
+- When the names within an object are not unique, it is unspecified which one of the values for a given key will be chosen. For instance, `#!json {"key": 2, "key": 1}` could be equal to either `#!json {"key": 1}` or `#!json {"key": 2}`.
 - Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see `dump`) in this order. For instance, both `#!json {"b": 1, "a": 2}` and `#!json {"a": 2, "b": 1}` will be stored and serialized as `#!json {"a": 2, "b": 1}`.
 - When comparing objects, the order of the name/value pairs is irrelevant. This makes objects interoperable in the sense that they will not be affected by these differences. For instance, `#!json {"b": 1, "a": 2}` and `#!json {"a": 2, "b": 1}` will be treated as equal.

@@ -151,18 +151,6 @@ In this class, the object's limit of nesting is not explicitly constrained. Howe

 Objects are stored as pointers in a `basic_json` type. That is, for any access to object values, a pointer of type `object_t*` must be dereferenced.

-### Converting maps with non-string keys
-
-A `std::map`/`std::unordered_map` whose key type is not string-like (e.g., `std::map<int, std::string>`) is
-converted to a JSON *array* of 2-element `[key, value]` arrays rather than a JSON object, because JSON object
-keys must be strings:
-
-```cpp
-std::map<int, std::string> m{{1, "one"}, {2, "two"}};
-json j = m;
-// j is [[1,"one"],[2,"two"]], not {"1":"one","2":"two"}
-```
-

 ## Arrays

@@ -63,10 +63,6 @@ In the default [`json`](../../api/json.md) type, numbers are stored as `#!c std:
 number without loss of precision. If this is impossible (e.g., if the number is too large), the number is stored as
 `#!c double`.

-Positive integers are stored as `#!c std::uint64_t`, while negative integers are stored as `#!c std::int64_t`. This
-distinction is determined at parse time: if the JSON number has a leading minus sign, it uses signed integer storage;
-otherwise, it uses unsigned integer storage.
-
 !!! info "Notes"

    - Numbers with a decimal digit or scientific notation are always stored as `#!c double`.
@@ -1,31 +0,0 @@
-# Debugging
-
-This page collects the library's built-in debugger integrations and other debugging-related features. They are
-not linked from a single place elsewhere in the docs, so are collected here.
-
-## Visual Studio (natvis)
-
-The repository ships [`nlohmann_json.natvis`](https://github.com/nlohmann/json/blob/develop/nlohmann_json.natvis)
-at its root, a [Natvis](https://learn.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects)
-file that gives `json`/`ordered_json` values a friendly, key/value debugger view instead of showing raw internal
-fields, when debugging with the MSVC debug engine (`cppvsdbg`) in Visual Studio or VS Code.
-
-Debug engines that wrap LLDB instead of the MSVC debug engine (for example, `codelldb` in VS Code) only have
-partial/experimental Natvis support, and commonly fall back to showing raw internal fields even with the
-`.natvis` file present. Switching to `cppvsdbg` where available, or checking your debug extension's own Natvis
-support/version, are the next things to try if this happens. There is currently no bundled LLDB-native
-pretty-printer script in this repository.
-
-## GDB
-
-The repository ships a [GDB Python pretty printer](https://github.com/nlohmann/json/tree/develop/tools/gdb_pretty_printer)
-under `tools/gdb_pretty_printer`, with its own usage instructions in that directory's `README.md`.
-
-## Extended exception diagnostics
-
-Defining [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md) before including the library augments
-`type_error`/`out_of_range`-style exceptions with a JSON Pointer to the offending value, which can help pinpoint
-where in a large document a runtime error occurred. This only applies to exceptions thrown *after* a value
-exists (e.g. during element access); parse errors, which happen before any value exists to point at, are not
-covered by this mechanism -- see [Parsing and exceptions](../features/parsing/parse_exceptions.md) for how parse
-errors report their own location instead.
@@ -326,9 +326,6 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
    ```
    [json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1
    ```
-    ```
-    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
-    ```

 ### json.exception.parse_error.113

@@ -896,7 +893,7 @@ A JSON Patch `add` operation cannot be applied because the target location's par

 !!! note

-    This exception was added in version 3.13.0. Before that, this situation hit an internal assertion (aborting the program in debug builds) or was silently ignored when assertions were disabled.
+    This exception was added in version 3.12.x. Before that, this situation hit an internal assertion (aborting the program in debug builds) or was silently ignored when assertions were disabled.

 ## Further exceptions

@@ -129,29 +129,6 @@ As described [above](#parse-errors-reading-non-ascii-characters), the library as
    }
    ```

-## Usage
-
-### Thread safety
-
-!!! question
-
-    Is `basic_json` thread-safe?
-
-No. `basic_json` provides no built-in synchronization, the same as `std::map` or `std::vector`. Concurrent reads of
-the same value from multiple threads are safe, as are concurrent (non-overlapping) accesses to independent `json`
-objects. However, any concurrent write to a `json` object -- or a concurrent read while another thread writes to the
-same object -- is a data race and requires external synchronization (e.g., a `std::mutex`) by the caller.
-
-### Schema validation
-
-!!! question
-
-    Does this library support JSON Schema validation?
-
-Not directly, but the companion project [json-schema-validator](https://github.com/pboettch/json-schema-validator)
-builds JSON Schema (draft 4, 6, 7, and 2019-09) validation on top of this library and is a common recommendation
-for this use case.
-
 ## Exceptions

 ### Parsing without exceptions
@@ -201,7 +178,7 @@ See [this section](../features/types/number_handling.md#number-serialization) on
    - Can I use `std::format("{}", j)` on a JSON value?
    - Can I use `fmt::format("{}", j)` or `fmt::print("{}", j)` (the [{fmt}](https://github.com/fmtlib/fmt) library) on a JSON value?

-`std::format` works out of the box since version 3.13.0, as long as the standard library provides
+`std::format` works out of the box since version 3.12.x, as long as the standard library provides
 `<format>` (see [`JSON_HAS_STD_FORMAT`](../api/macros/json_has_std_format.md)); see
 [`std::formatter<basic_json>`](../api/basic_json/std_formatter.md) for details, including the `#!cpp "{:#}"`
 pretty-print spec, indent widths (`#!cpp "{:2}"`), and custom indent characters (`#!cpp "{:.>#}"`).
@@ -181,15 +181,3 @@ Execute the test suite with [Valgrind](https://valgrind.org). This option is `OF

 Build the experimental [C++ module](../features/modules.md) `nlohmann.json` (requires CMake 3.28 or later and C++20).
 This option is `OFF` by default.
-
-A consuming project must link the dedicated `nlohmann_json_modules` CMake target (not just
-`nlohmann_json::nlohmann_json`) for `import nlohmann.json;` to resolve:
-
-```cmake
-set(NLOHMANN_JSON_BUILD_MODULES ON)
-add_subdirectory(path/to/json)
-
-add_executable(myproject main.cpp)
-target_link_libraries(myproject PRIVATE nlohmann_json_modules)
-target_compile_definitions(myproject PRIVATE NLOHMANN_JSON_BUILD_MODULES)
-```
@@ -930,15 +930,6 @@ If you are using [CocoaPods](https://cocoapods.org), you can use the library by
 to your podfile (see [an example](https://bitbucket.org/benman/nlohmann_json-cocoapod/src/master/)). Please file issues
 [here](https://bitbucket.org/benman/nlohmann_json-cocoapod/issues?status=new&status=open).

-## ESP-IDF and PlatformIO
-
-There is no official package published to the [ESP-IDF Component Registry](https://components.espressif.com) or the
-[PlatformIO Registry](https://registry.platformio.org). A community-maintained fork,
-[Johboh/nlohmann-json](https://github.com/Johboh/nlohmann-json), publishes this library to both registries on each
-new release and can be used as an unofficial component/package for ESP-IDF and PlatformIO projects. As the library
-is header-only, it can otherwise be used directly by adding its `include/` directory to your component's/project's
-include paths, like any other integration method described on this page.
-
 ![](https://img.shields.io/cocoapods/v/nlohmann_json)

 !!! warning
@@ -1,4 +0,0 @@
-User-agent: *
-Allow: /
-
-Sitemap: https://json.nlohmann.me/sitemap.xml
@@ -1,25 +0,0 @@
-"""Copy each documentation page's Markdown source into the built site."""
-
-# Creates a `<path>.md` sibling of each HTML output (for example,
-# `features/comments/` becomes `features/comments.md`) so agents and tools can
-# fetch the raw Markdown directly instead of parsing rendered HTML.
-
-import os
-import shutil
-
-_pages = []
-
-
-def on_files(files, config):
-    global _pages
-    _pages = [f for f in files if f.is_documentation_page()]
-    return files
-
-
-def on_post_build(config):
-    site_dir = config["site_dir"]
-    for file in _pages:
-        url = file.url.rstrip("/")
-        target = os.path.join(site_dir, (url or "index") + ".md")
-        os.makedirs(os.path.dirname(target), exist_ok=True)
-        shutil.copyfile(file.abs_src_path, target)
@@ -56,7 +56,6 @@ nav:
      - home/architecture.md
      - home/customers.md
      - home/sponsors.md
-      - home/debugging.md
  - Features:
      - features/index.md
      - features/arbitrary_types.md
@@ -368,9 +367,6 @@ markdown_extensions:
      auto_append:
        - ../includes/glossary.md

-hooks:
-  - hooks/copy_markdown_source.py
-
 plugins:
  - search:
      separator: '[\s\-\.]'
@@ -393,33 +389,6 @@ plugins:
        - https://nlohmann.github.io/json/*
        - mailto:*
  - privacy
-  - llmstxt:
-      markdown_description: >
-        JSON for Modern C++ is a C++11 header-only library implementing a JSON
-        value type with an STL-like API, JSON Pointer/Patch, CBOR/MessagePack/
-        BSON/UBJSON/BJData binary format support, and a SAX-style parser interface.
-      sections:
-        Home:
-          - index.md
-          - home/*.md
-        Features:
-          - features/*.md
-          - features/binary_formats/*.md
-          - features/element_access/*.md
-          - features/parsing/*.md
-          - features/types/*.md
-        Integration:
-          - integration/*.md
-        API Documentation:
-          - api/*.md
-          - api/basic_json/*.md
-          - api/adl_serializer/*.md
-          - api/byte_container_with_subtype/*.md
-          - api/json_pointer/*.md
-          - api/json_sax/*.md
-          - api/macros/*.md
-        Community:
-          - community/*.md

 extra_css:
  - css/custom.css
@@ -7,6 +7,5 @@ mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
 mkdocs-redirects==1.2.3                             # plugin "redirects"
 mkdocs-htmlproofer-plugin==1.5.0                    # plugin "htmlproofer"
-mkdocs-llmstxt==0.5.0                               # plugin "llmstxt"

 PyYAML==6.0.3                                       # linter
@@ -19,7 +19,6 @@
 #include <unordered_map> // unordered_map
 #include <utility> // pair, declval
 #include <valarray> // valarray
-#include <vector> // vector

 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -333,7 +332,6 @@ template < typename BasicJsonType, typename ConstructibleArrayType,
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
-               !is_compatible_binary_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
@@ -379,25 +377,6 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t&
    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
 }

-template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
-                         int > = 0 >
-inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
-{
-    if (j.is_binary())
-    {
-        bin = static_cast<CompatibleArrayType>(*j.template get_ptr<const typename BasicJsonType::binary_t*>());
-    }
-    else if (j.is_array())
-    {
-        from_json_array_impl(j, bin, priority_tag<3> {});
-    }
-    else
-    {
-        JSON_THROW(type_error::create(302, concat("type must be binary or array, but is ", j.type_name()), &j));
-    }
-}
-
 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)
@@ -355,7 +355,6 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
-                         !is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_basic_json<CompatibleArrayType>::value,
                         int > = 0 >
 inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
@@ -369,14 +368,6 @@ inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bi
    external_constructor<value_t::binary>::construct(j, bin);
 }

-template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
-                         int > = 0 >
-inline void to_json(BasicJsonType& j, const CompatibleArrayType& bin)
-{
-    external_constructor<value_t::binary>::construct(j, typename BasicJsonType::binary_t(bin));
-}
-
 template<typename BasicJsonType, typename T,
         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
@@ -430,7 +430,7 @@ class wide_string_input_adapter

    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
    template<class T>
-    JSON_HEDLEY_NO_RETURN std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
+    std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
    {
        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
    }
@@ -517,18 +517,18 @@ struct container_input_adapter_factory< ContainerType,
       {
           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));

-           static adapter_type create(ContainerType&& container)
+           static adapter_type create(const ContainerType& container)
 {
-    return input_adapter(begin(std::forward<ContainerType>(container)), end(std::forward<ContainerType>(container)));
+    return input_adapter(begin(container), end(container));
 }
       };

 }  // namespace container_input_adapter_factory_impl

 template<typename ContainerType>
-typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType&& container)
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
 {
-    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
 }

 // specialization for std::string
@@ -146,11 +146,6 @@
        #define JSON_HAS_RANGES 0
    #elif defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 160000
        #define JSON_HAS_RANGES 0
-        // nvcc CUDA 12.0/12.1 chokes on the enable_borrowed_range variable-template
-        // syntax when compiling as CUDA source; fixed in CUDA 12.2 (issue #3907)
-    #elif defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 12 \
-        && defined(__CUDACC_VER_MINOR__) && (__CUDACC_VER_MINOR__ == 0 || __CUDACC_VER_MINOR__ == 1)
-        #define JSON_HAS_RANGES 0
    #elif defined(__cpp_lib_ranges)
        #define JSON_HAS_RANGES 1
    #else
@@ -13,7 +13,6 @@
 #include <tuple> // tuple
 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
 #include <utility> // declval
-#include <vector> // vector
 #if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
    #include <cstddef> // byte
 #endif
@@ -560,14 +559,6 @@ template<typename BasicJsonType, typename CompatibleType>
 struct is_compatible_type
    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};

-template<typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_binary_type
-{
-    static constexpr bool value =
-        std::is_same<typename BasicJsonType::binary_t::container_type, CompatibleArrayType>::value &&
-        !std::is_same<typename BasicJsonType::binary_t::container_type, std::vector<std::uint8_t>>::value;
-};
-
 template<typename BasicJsonType, typename CompatibleReferenceType>
 struct is_compatible_reference_type_impl
 {
@@ -465,12 +465,18 @@ class serializer
                            {
                                if (codepoint <= 0xFFFF)
                                {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
                                }
                                else
                                {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)));
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
                                }
                            }
                            else
@@ -677,32 +683,6 @@ class serializer
        return result;
    }

-    /*!
-     * @brief write a lowercase "\uXXXX" escape sequence into @a string_buffer
-     *
-     * Branch-free replacement for `snprintf(buf, 7, "\\u%04x", codeunit)` in the
-     * string escaping hot path. It writes exactly six characters ('\\', 'u' and
-     * four hex digits) at position @a pos of @a string_buffer via a nibble
-     * lookup table, avoiding the format-string parsing and locale machinery of
-     * `snprintf`. Advances @a pos by the number of bytes written (6).
-     *
-     * @param[in] pos       position in @a string_buffer to write at; there must
-     *                      be at least 6 bytes of headroom
-     * @param[in] codeunit  16-bit value to encode
-     */
-    void write_u_escape(std::size_t& pos, std::uint16_t codeunit) noexcept
-    {
-        JSON_ASSERT(string_buffer.size() - pos >= 6);
-        constexpr const char* nibble_to_hex = "0123456789abcdef";
-        string_buffer[pos + 0] = '\\';
-        string_buffer[pos + 1] = 'u';
-        string_buffer[pos + 2] = nibble_to_hex[(codeunit >> 12u) & 0x0Fu];
-        string_buffer[pos + 3] = nibble_to_hex[(codeunit >> 8u) & 0x0Fu];
-        string_buffer[pos + 4] = nibble_to_hex[(codeunit >> 4u) & 0x0Fu];
-        string_buffer[pos + 5] = nibble_to_hex[codeunit & 0x0Fu];
-        pos += 6;
-    }
-
    // templates to avoid warnings about useless casts
    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
    bool is_negative_number(NumberType x)
@@ -3776,6 +3776,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return *this == basic_json(rhs);
    }

+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
    /// @brief comparison: 3-way
    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
@@ -3881,6 +3892,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
        return !(lhs == rhs);
    }

@@ -189,7 +189,6 @@
 #include <unordered_map> // unordered_map
 #include <utility> // pair, declval
 #include <valarray> // valarray
-#include <vector> // vector

 // #include <nlohmann/detail/exceptions.hpp>
 //     __ _____ _____ _____
@@ -2521,11 +2520,6 @@ JSON_HEDLEY_DIAGNOSTIC_POP
        #define JSON_HAS_RANGES 0
    #elif defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 160000
        #define JSON_HAS_RANGES 0
-        // nvcc CUDA 12.0/12.1 chokes on the enable_borrowed_range variable-template
-        // syntax when compiling as CUDA source; fixed in CUDA 12.2 (issue #3907)
-    #elif defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 12 \
-        && defined(__CUDACC_VER_MINOR__) && (__CUDACC_VER_MINOR__ == 0 || __CUDACC_VER_MINOR__ == 1)
-        #define JSON_HAS_RANGES 0
    #elif defined(__cpp_lib_ranges)
        #define JSON_HAS_RANGES 1
    #else
@@ -3593,7 +3587,6 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <tuple> // tuple
 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
 #include <utility> // declval
-#include <vector> // vector
 #if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
    #include <cstddef> // byte
 #endif
@@ -4323,14 +4316,6 @@ template<typename BasicJsonType, typename CompatibleType>
 struct is_compatible_type
    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};

-template<typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_binary_type
-{
-    static constexpr bool value =
-        std::is_same<typename BasicJsonType::binary_t::container_type, CompatibleArrayType>::value &&
-        !std::is_same<typename BasicJsonType::binary_t::container_type, std::vector<std::uint8_t>>::value;
-};
-
 template<typename BasicJsonType, typename CompatibleReferenceType>
 struct is_compatible_reference_type_impl
 {
@@ -5474,7 +5459,6 @@ template < typename BasicJsonType, typename ConstructibleArrayType,
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
-               !is_compatible_binary_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
@@ -5520,25 +5504,6 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t&
    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
 }

-template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
-                         int > = 0 >
-inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
-{
-    if (j.is_binary())
-    {
-        bin = static_cast<CompatibleArrayType>(*j.template get_ptr<const typename BasicJsonType::binary_t*>());
-    }
-    else if (j.is_array())
-    {
-        from_json_array_impl(j, bin, priority_tag<3> {});
-    }
-    else
-    {
-        JSON_THROW(type_error::create(302, concat("type must be binary or array, but is ", j.type_name()), &j));
-    }
-}
-
 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)
@@ -6413,7 +6378,6 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
-                         !is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_basic_json<CompatibleArrayType>::value,
                         int > = 0 >
 inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
@@ -6427,14 +6391,6 @@ inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bi
    external_constructor<value_t::binary>::construct(j, bin);
 }

-template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
-                         int > = 0 >
-inline void to_json(BasicJsonType& j, const CompatibleArrayType& bin)
-{
-    external_constructor<value_t::binary>::construct(j, typename BasicJsonType::binary_t(bin));
-}
-
 template<typename BasicJsonType, typename T,
         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
@@ -7306,7 +7262,7 @@ class wide_string_input_adapter

    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
    template<class T>
-    JSON_HEDLEY_NO_RETURN std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
+    std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
    {
        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
    }
@@ -7393,18 +7349,18 @@ struct container_input_adapter_factory< ContainerType,
       {
           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));

-           static adapter_type create(ContainerType&& container)
+           static adapter_type create(const ContainerType& container)
 {
-    return input_adapter(begin(std::forward<ContainerType>(container)), end(std::forward<ContainerType>(container)));
+    return input_adapter(begin(container), end(container));
 }
       };

 }  // namespace container_input_adapter_factory_impl

 template<typename ContainerType>
-typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType&& container)
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
 {
-    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
 }

 // specialization for std::string
@@ -20006,12 +19962,18 @@ class serializer
                            {
                                if (codepoint <= 0xFFFF)
                                {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
                                }
                                else
                                {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)));
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
                                }
                            }
                            else
@@ -20218,32 +20180,6 @@ class serializer
        return result;
    }

-    /*!
-     * @brief write a lowercase "\uXXXX" escape sequence into @a string_buffer
-     *
-     * Branch-free replacement for `snprintf(buf, 7, "\\u%04x", codeunit)` in the
-     * string escaping hot path. It writes exactly six characters ('\\', 'u' and
-     * four hex digits) at position @a pos of @a string_buffer via a nibble
-     * lookup table, avoiding the format-string parsing and locale machinery of
-     * `snprintf`. Advances @a pos by the number of bytes written (6).
-     *
-     * @param[in] pos       position in @a string_buffer to write at; there must
-     *                      be at least 6 bytes of headroom
-     * @param[in] codeunit  16-bit value to encode
-     */
-    void write_u_escape(std::size_t& pos, std::uint16_t codeunit) noexcept
-    {
-        JSON_ASSERT(string_buffer.size() - pos >= 6);
-        constexpr const char* nibble_to_hex = "0123456789abcdef";
-        string_buffer[pos + 0] = '\\';
-        string_buffer[pos + 1] = 'u';
-        string_buffer[pos + 2] = nibble_to_hex[(codeunit >> 12u) & 0x0Fu];
-        string_buffer[pos + 3] = nibble_to_hex[(codeunit >> 8u) & 0x0Fu];
-        string_buffer[pos + 4] = nibble_to_hex[(codeunit >> 4u) & 0x0Fu];
-        string_buffer[pos + 5] = nibble_to_hex[codeunit & 0x0Fu];
-        pos += 6;
-    }
-
    // templates to avoid warnings about useless casts
    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
    bool is_negative_number(NumberType x)
@@ -24666,6 +24602,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return *this == basic_json(rhs);
    }

+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
    /// @brief comparison: 3-way
    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
@@ -24771,6 +24718,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
        return !(lhs == rhs);
    }

@@ -68,11 +68,7 @@ target_compile_options(test_main PUBLIC
    #       Disable warning C4566: character represented by universal-character-name '\uFF01'
    #                              cannot be represented in the current code page (1252)
    #       Disable warning C4996: 'nlohmann::basic_json<...>::operator <<': was declared deprecated
-    #       Disable warning C4702: unreachable code; wide_string_input_adapter::get_elements()
-    #                              is annotated JSON_HEDLEY_NO_RETURN (it always throws), which
-    #                              makes MSVC flag the code following its call in binary_reader.hpp
-    #                              as unreachable for that instantiation, in both Debug and Release
-    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702>
+    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;$<$<CONFIG:Release>:/wd4702>>
    # https://github.com/nlohmann/json/issues/1114
    $<$<CXX_COMPILER_ID:MSVC>:/bigobj> $<$<BOOL:${MINGW}>:-Wa,-mbig-obj>

@@ -3,18 +3,7 @@ project(json_cuda LANGUAGES CUDA)

 add_executable(json_cuda json_cuda.cu)
 target_include_directories(json_cuda PRIVATE ../../include)
-
-# nvcc added C++20 support in CUDA 12.0 and C++17 in CUDA 11.0; pick the
-# newest standard the detected compiler actually supports (see #3907)
-# instead of hard-requiring one standard for every CUDA version.
-if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0)
-    set(json_cuda_std 20)
-elseif(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
-    set(json_cuda_std 17)
-else()
-    set(json_cuda_std 11)
-endif()
-target_compile_features(json_cuda PUBLIC cuda_std_${json_cuda_std})
+target_compile_features(json_cuda PUBLIC cuda_std_11)
 set_target_properties(json_cuda PROPERTIES
    CUDA_EXTENSIONS OFF
    CUDA_STANDARD_REQUIRED ON
@@ -16,20 +16,4 @@ int main()
    // regression for #3013 (ordered_json::reset() compile error with nvcc)
    nlohmann::ordered_json metadata;
    metadata.erase("key");
-
-    // exercise comparisons (operator==/operator<=>, gated by
-    // JSON_HAS_THREE_WAY_COMPARISON, independent of JSON_HAS_RANGES) and
-    // range-based iteration (exercises iteration_proxy/ranges machinery
-    // beyond just the enable_borrowed_range specialization) — see #3907
-    nlohmann::json a = {1, 2, 3};
-    nlohmann::json b = {1, 2, 3};
-    static_cast<void>(a == b);
-#if JSON_HAS_THREE_WAY_COMPARISON
-    static_cast<void>(a <=> b); // *NOPAD*
-    static_cast<void>(a <=> 1); // *NOPAD*
-#endif
-    for (const auto& element : a)
-    {
-        static_cast<void>(element);
-    }
 }
@@ -232,9 +232,6 @@ TEST_CASE("algorithms")
            // only the first four elements are expected to be sorted, the rest are
            // unspecified by the standard
            const json expected({nullptr, false, true, 3});
-            // std::equal below only bounds-checks the first range; assert the
-            // second range is at least as long to rule out an over-read (CWE-126)
-            CHECK(std::distance(begin(expected), end(expected)) >= 4);
            CHECK(std::equal(j.begin(), j.begin() + 4, begin(expected)));
        }
    }
@@ -24,7 +24,7 @@ struct bad_allocator : std::allocator<T>
    template<class U> bad_allocator(const bad_allocator<U>& /*unused*/) { }

    template<class... Args>
-    [[noreturn]] void construct(T* /*unused*/, Args&& ... /*unused*/) // NOLINT(cppcoreguidelines-missing-std-forward)
+    void construct(T* /*unused*/, Args&& ... /*unused*/) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        throw std::bad_alloc();
    }
@@ -322,12 +322,14 @@ TEST_CASE("alternative string type")

    SECTION("JSON pointer")
    {
-        // Direct conversion from a json literal to alt_json is not supported due to issue #3425:
-        // alt_json's string_t (alt_string) is not directly constructible from std::string, so the
-        // cross-basic_json conversion falls back to the array-conversion path, incorrectly representing
-        // objects as arrays of [key, value] pairs and strings as arrays of character codes.
-        // See https://github.com/nlohmann/json/issues/3425 for details.
-        // Workaround: use alt_json::parse() instead of implicit conversion.
+        // conversion from json to alt_json fails to compile (see #3425);
+        // attempted fix(*) produces: [[['b','a','r'],['b','a','z']]] (with each char being an integer)
+        // (*) disable implicit conversion for json_refs of any basic_json type
+        // alt_json j = R"(
+        // {
+        //     "foo": ["bar", "baz"]
+        // }
+        // )"_json;
        auto j = alt_json::parse(R"({"foo": ["bar", "baz"]})");

        CHECK(j.at(alt_json::json_pointer("/foo/0")) == j["foo"][0]);
@@ -369,7 +369,6 @@ TEST_CASE("lexicographical comparison operators")
        SECTION("comparison: not equal")
        {
            // check that two values compare unequal as expected
-            // operator!= now means exactly !(a==b) without special cases for NaN/discarded
            for (size_t i = 0; i < j_values.size(); ++i)
            {
                for (size_t j = 0; j < j_values.size(); ++j)
@@ -377,12 +376,25 @@ TEST_CASE("lexicographical comparison operators")
                    CAPTURE(i)
                    CAPTURE(j)

-                    CHECK((j_values[i] != j_values[j]) == !(j_values[i] == j_values[j]));
+                    if (json::compares_unordered(j_values[i], j_values[j], true))
+                    {
+                        // if two values compare unordered,
+                        // check that the boolean comparison result is always false
+                        CHECK_FALSE(j_values[i] != j_values[j]);
+                    }
+                    else
+                    {
+                        // otherwise, check that they compare according to their definition
+                        // as the inverse of equal
+                        CHECK((j_values[i] != j_values[j]) == !(j_values[i] == j_values[j]));
+                    }
                }
            }

            // compare with null pointer
            const json j_null;
+            CHECK((j_null != nullptr) == false);
+            CHECK((nullptr != j_null) == false);
            CHECK((j_null != nullptr) == !(j_null == nullptr));
            CHECK((nullptr != j_null) == !(nullptr == j_null));
        }
@@ -582,34 +594,3 @@ TEST_CASE("lexicographical comparison operators")
    }
 #endif
 }
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-// JSON_HAS_CPP_20 (do not remove; see note at top of file)
-
-TEST_CASE("regression #3868 - heterogeneous comparisons compile under C++20 (P2468R2)")
-{
-    // Issue #3868: operator!= was preventing compiler from synthesizing reversed
-    // operator== candidates under C++20's P2468R2 rewritten candidate rules.
-    // Verify that heterogeneous comparisons now work.
-
-    SECTION("string vs json")
-    {
-        std::string s = "string";
-        json j = "string";
-        CHECK(s == j);
-        CHECK(j == s);
-        CHECK_FALSE(s != j);
-        CHECK_FALSE(j != s);
-    }
-
-    SECTION("other heterogeneous types")
-    {
-        int i = 42;
-        json j = 42;
-        CHECK(i == j);
-        CHECK(j == i);
-        CHECK_FALSE(i != j);
-        CHECK_FALSE(j != i);
-    }
-}
-#endif
@@ -278,7 +278,7 @@ TEST_CASE("constructors")
            const auto t = j.get<std::tuple<int, float, std::string>>();
            CHECK(std::get<0>(t) == j[0]);
            CHECK(std::get<1>(t) == j[1]);
-            CHECK(std::get<2>(t) == j[2]);
+            // CHECK(std::get<2>(t) == j[2]); // commented out due to CI issue, see https://github.com/nlohmann/json/pull/3985 and https://github.com/nlohmann/json/issues/4025
        }

        SECTION("std::tuple tie")
@@ -168,32 +168,6 @@ TEST_CASE("convenience functions")
        CHECK_THROWS_WITH_AS(check_escaped("\xC2"), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
    }

-    SECTION("string escape with ensure_ascii")
-    {
-        // control characters are escaped regardless of ensure_ascii
-        check_escaped("\x01", "\\u0001", true);
-        check_escaped("\x1f", "\\u001f", true);
-
-        // non-ASCII code points in the Basic Multilingual Plane are emitted as
-        // a single lowercase \uXXXX escape (exercises every nibble position)
-        check_escaped("\xC2\x80", "\\u0080", true);         // U+0080
-        check_escaped("\xC3\xBF", "\\u00ff", true);         // U+00FF (ÿ)
-        check_escaped("\xDF\xBF", "\\u07ff", true);         // U+07FF
-        check_escaped("\xE4\xBD\xA0", "\\u4f60", true);     // U+4F60 (你)
-        check_escaped("\xEA\xAF\x8D", "\\uabcd", true);     // U+ABCD
-        check_escaped("\xEF\xBF\xBD", "\\ufffd", true);     // U+FFFD (replacement char, all-f nibbles)
-
-        // code points outside the BMP are emitted as a UTF-16 surrogate pair
-        // of two lowercase \uXXXX escapes
-        check_escaped("\xF0\x90\x80\x80", "\\ud800\\udc00", true); // U+10000 (lowest astral)
-        check_escaped("\xF0\x9F\x98\x80", "\\ud83d\\ude00", true); // U+1F600 (😀)
-        check_escaped("\xF4\x8F\xBF\xBF", "\\udbff\\udfff", true); // U+10FFFF (highest code point)
-
-        // with ensure_ascii disabled, non-ASCII input is passed through verbatim
-        check_escaped("\xE4\xBD\xA0", "\xE4\xBD\xA0", false);
-        check_escaped("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", false);
-    }
-
    SECTION("string concat")
    {
        using nlohmann::detail::concat;
@@ -1761,27 +1761,16 @@ TEST_CASE("std::filesystem::path")
 }
 #endif

+#if !JSON_USE_IMPLICIT_CONVERSIONS
 TEST_CASE("std::optional")
 {
    SECTION("null")
    {
-        const json j_null;
-        const std::optional<std::string> opt_null;
+        json j_null;
+        std::optional<std::string> opt_null;

        CHECK(json(opt_null) == j_null);
        CHECK(j_null.get<std::optional<std::string>>() == std::nullopt);
-
-        // Constructing std::optional<T> directly from JSON null throws because
-        // std::optional's own converting constructor is chosen over basic_json's
-        // operator T(). This is a language-level limitation (std::optional<T> is
-        // constructible from T, and T is constructible from basic_json via the
-        // operator); there is no SFINAE path that distinguishes "call from inside
-        // std::optional's constructor" from "direct call". Use get<std::optional<T>>()
-        // or get_to() instead for correct null handling. See #4864 and #5246.
-        CHECK_THROWS_WITH_AS(std::optional<std::string>(j_null),
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
-                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
    }

    SECTION("string")
@@ -1830,6 +1819,7 @@ TEST_CASE("std::optional")
    }
 }
 #endif
+#endif

 #ifdef JSON_HAS_CPP_17
    #undef JSON_HAS_CPP_17
@@ -227,11 +227,6 @@ bool check_utf8()
    // Runtime check of the active ANSI code page
    // 65001 == UTF-8
    return GetACP() == 65001;
-#elif defined(__ICC) || defined(__INTEL_COMPILER)
-    // classic Intel ICC does not encode narrow string literals containing
-    // non-ASCII source characters as UTF-8, so comparing a decoded u8 literal
-    // against a narrow string literal containing the same characters fails
-    return false;
 #else
    return true;
 #endif
@@ -942,7 +942,7 @@ TEST_CASE("iterators 2")
                json j_expected{5, 4, 3, 2, 1};

                auto reversed = j | std::views::reverse;
-                CHECK(reversed == j_expected);
+                CHECK(std::ranges::equal(reversed, j_expected));
            }

            SECTION("transform")
@@ -798,9 +798,7 @@ TEST_CASE("regression tests 2")

 #ifdef JSON_HAS_CPP_20
 #ifndef _LIBCPP_VERSION // see https://github.com/nlohmann/json/issues/4490
-    // classic Intel ICC reports <span> as includable but cannot actually compile
-    // std::span/std::as_bytes usage below
-#if __has_include(<span>) && !defined(__ICC) && !defined(__INTEL_COMPILER)
+#if __has_include(<span>)
    SECTION("issue #2546 - parsing containers of std::byte")
    {
        const char DATA[] = R"("Hello, world!")"; // NOLINT(misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
@@ -1136,40 +1134,6 @@ TEST_CASE("regression tests 2")
        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{};
@@ -54,47 +54,6 @@ TEST_CASE("Custom container non-member begin/end")

 }

-struct MyContainerNonConstADL
-{
-    char* data;
-    std::size_t size;
-};
-
-char* begin(MyContainerNonConstADL& c)
-{
-    return c.data;
-}
-
-char* end(MyContainerNonConstADL& c)
-{
-    return c.data + c.size; // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-}
-
-TEST_CASE("Custom container non-member non-const begin/end")
-{
-    // Container with lvalue-only non-const ADL begin/end (bug reproduction)
-    std::string raw_data = "[1,2,3,4]";
-    MyContainerNonConstADL data{&raw_data[0], raw_data.size()}; // NOLINT(readability-container-data-pointer)
-    const json as_json = json::parse(data);
-    CHECK(as_json.at(0) == 1);
-    CHECK(as_json.at(1) == 2);
-    CHECK(as_json.at(2) == 3);
-    CHECK(as_json.at(3) == 4);
-
-    // Same container with accept()
-    CHECK(json::accept(data));
-}
-
-TEST_CASE("Custom container non-member begin/end, rvalue")
-{
-    // Regression check: rvalue container parsing should still work
-    const json as_json = json::parse(MyContainer{"[1,2,3,4]"});
-    CHECK(as_json.at(0) == 1);
-    CHECK(as_json.at(1) == 2);
-    CHECK(as_json.at(2) == 3);
-    CHECK(as_json.at(3) == 4);
-}
-
 TEST_CASE("Custom container member begin/end")
 {
    struct MyContainer2