Bump astyle from 3.4.13 to 3.6.18 in /tools/astyle

Bumps [astyle](https://github.com/Freed-Wu/astyle-wheel) from 3.4.13 to 3.6.18. - [Release notes](https://github.com/Freed-Wu/astyle-wheel/releases) - [Commits](https://github.com/Freed-Wu/astyle-wheel/commits) --- updated-dependencies: - dependency-name: astyle dependency-version: 3.6.18 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
2026-09-25 09:20:32 +00:00 · 2026-08-31 15:43:48 +00:00
124 changed files with 4629 additions and 14513 deletions
@@ -108,9 +108,7 @@ The tests are located in [`tests/src/unit-*.cpp`](https://github.com/nlohmann/js
 are structured along the features of the library or the nature of the tests. Usually, it should be clear from the
 context which existing file needs to be extended, and only very few cases require creating new test files.

-When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
-`unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
-MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
+When fixing a bug, edit `unit-regression2.cpp` and add a section referencing the fixed issue.

 #### Exceptions

@@ -11,7 +11,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -34,7 +34,7 @@ jobs:

    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -9,7 +9,7 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+      uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
      with:
        egress-policy: audit

@@ -27,7 +27,7 @@ jobs:

    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+      uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
      with:
        egress-policy: audit

@@ -38,14 +38,14 @@ jobs:

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+      uses: github/codeql-action/init@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
      with:
        languages: c-cpp

    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+      uses: github/codeql-action/autobuild@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+      uses: github/codeql-action/analyze@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
@@ -19,7 +19,7 @@ jobs:
      pull-requests: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -17,7 +17,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -27,7 +27,7 @@ jobs:
      security-events: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -43,6 +43,6 @@ jobs:
          output: 'flawfinder_results.sarif'

      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+        uses: github/codeql-action/upload-sarif@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -17,7 +17,7 @@ jobs:

    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -26,7 +26,7 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -36,7 +36,7 @@ jobs:

    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -76,6 +76,6 @@ jobs:

      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+        uses: github/codeql-action/upload-sarif@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
        with:
          sarif_file: results.sarif
@@ -32,7 +32,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -61,7 +61,7 @@ jobs:

      # Upload SARIF file generated in previous step
      - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+        uses: github/codeql-action/upload-sarif@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -16,7 +16,7 @@ jobs:

    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -35,7 +35,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -60,7 +60,7 @@ jobs:
        target: [ci_test_amalgamation, ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_simdutf]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -118,7 +118,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -369,7 +369,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -392,7 +392,7 @@ jobs:
        target: [ci_test_examples, ci_test_build_documentation]
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
        with:
          egress-policy: audit

@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef
+.PHONY: pretty clean ChangeLog.md release

 ##########################################################################
 # configuration
@@ -41,8 +41,6 @@ all:
 	@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
 	@echo "pretty - beautify code with Artistic Style"
 	@echo "run_benchmarks - build and run benchmarks"
-	@echo "update_hedley - download Hedley and regenerate hedley.hpp / hedley_undef.hpp"
-	@echo "update_hedley_undef - rebuild hedley_undef.hpp from the JSON_HEDLEY_* #define names in hedley.hpp"


 ##########################################################################
@@ -243,24 +241,11 @@ update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
+	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp
-	$(MAKE) update_hedley_undef
+	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(MAKE) amalgamate

-# Rebuild hedley_undef.hpp from every JSON_HEDLEY_* name that hedley.hpp
-# #defines. Hedley does not #undef all of its public macros internally (see
-# #5408), so grepping those #undef lines misses names such as
-# JSON_HEDLEY_PRAGMA. cmake/scripts/gen_hedley_undef_check.cmake is the
-# single source of truth for this extraction (tests/CMakeLists.txt uses the
-# same script, in MODE=checks, to generate the matching leak-check test), so
-# the vendored header, the generated #undef list, and the regression test
-# cannot drift apart.
-update_hedley_undef:
-	cmake -DHEDLEY_HPP=include/nlohmann/thirdparty/hedley/hedley.hpp \
-	      -DOUTPUT=include/nlohmann/thirdparty/hedley/hedley_undef.hpp \
-	      -DMODE=undef \
-	      -P cmake/scripts/gen_hedley_undef_check.cmake
-
 ##########################################################################
 # serve_header.py
 ##########################################################################
@@ -212,24 +212,6 @@ add_custom_target(ci_test_legacycomparison
    COMMENT "Compile and test with legacy discarded value comparison enabled"
 )

-###############################################################################
-# Validate UTF-8 with simdutf.
-###############################################################################
-
-add_custom_target(ci_test_simdutf
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_TestSimdutf=ON
-    # simdutf needs C++17, so the library falls back to its scalar validator
-    # below that: build the suite at C++11 to cover the fallback with the macro
-    # defined, and at C++17 to run every test against simdutf itself
-    "-DJSON_TestStandards=11\;17"
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_simdutf
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_simdutf
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_simdutf && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with simdutf UTF-8 validation enabled"
-)
-
 ###############################################################################
 # Enable brace-init copy semantics.
 ###############################################################################
@@ -1,112 +0,0 @@
-# Shared extractor for the JSON_HEDLEY_* macro names defined in hedley.hpp.
-#
-# Every macro that hedley.hpp #defines must be #undef-ed again once json.hpp
-# has been fully processed (see include/nlohmann/detail/macro_unscope.hpp
-# and https://github.com/nlohmann/json/issues/5408). Deriving the macro list
-# straight from hedley.hpp here -- instead of hand-maintaining it in two
-# places -- means hedley_undef.hpp and the regression test that checks for
-# leaked macros can never drift apart, even after a future `make
-# update_hedley` pulls in new macros from upstream Hedley.
-#
-#   MODE=undef  (default): write hedley_undef.hpp (SPDX header, #pragma once,
-#               one #undef per macro name) -- used by `make update_hedley_undef`
-#   MODE=checks:            write one #ifdef/FAIL_CHECK/#endif per macro name,
-#               meant to be #include-d inside a TEST_CASE -- used by
-#               tests/CMakeLists.txt to (re)generate the include for
-#               tests/src/unit-no-macro-leak.cpp
-#
-# Required variables:
-#   HEDLEY_HPP  path to include/nlohmann/thirdparty/hedley/hedley.hpp
-#   OUTPUT      path of the file to (over)write
-# Optional:
-#   MODE        "undef" (default) or "checks"
-
-if(NOT DEFINED HEDLEY_HPP OR NOT DEFINED OUTPUT)
-    message(FATAL_ERROR "HEDLEY_HPP and OUTPUT must be set")
-endif()
-
-if(NOT EXISTS "${HEDLEY_HPP}")
-    message(FATAL_ERROR "Hedley header not found: ${HEDLEY_HPP}")
-endif()
-
-if(NOT DEFINED MODE)
-    set(MODE undef)
-endif()
-
-if(NOT MODE STREQUAL "undef" AND NOT MODE STREQUAL "checks")
-    message(FATAL_ERROR "MODE must be undef or checks, got: ${MODE}")
-endif()
-
-# Line-anchored, like `grep -oE "^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+"`.
-# Unanchored matching would also pick up JSON_HEDLEY_* mentions inside
-# comments or string literals elsewhere in the file, which must not turn
-# into #undef lines.
-file(STRINGS "${HEDLEY_HPP}" hedley_lines)
-set(macro_names)
-foreach(line IN LISTS hedley_lines)
-    if("${line}" MATCHES "^[ \t]*#[ \t]*define[ \t]+(JSON_HEDLEY_[A-Za-z0-9_]+)")
-        list(APPEND macro_names "${CMAKE_MATCH_1}")
-    endif()
-endforeach()
-
-if(NOT macro_names)
-    message(FATAL_ERROR "No JSON_HEDLEY_* macros found in ${HEDLEY_HPP}")
-endif()
-
-list(REMOVE_DUPLICATES macro_names)
-# Lexicographic, locale-independent (ASCII-only names) -- matches `LC_ALL=C sort`.
-list(SORT macro_names COMPARE STRING)
-list(LENGTH macro_names macro_count)
-
-set(generated "")
-if(MODE STREQUAL "undef")
-    # Same banner `make update_hedley_undef` would stamp by hand, so the
-    # recipe is self-contained and its output is byte-stable across reruns.
-    # The embedded SPDX tags below are part of the *generated* file's
-    # content, not a REUSE header for this .cmake script itself (which is
-    # already covered by the blanket "Files: *" rule in .reuse/dep5) -- keep
-    # them wrapped in REUSE-IgnoreStart/End so `reuse lint` does not try to
-    # parse "MIT\n")" as this file's own SPDX-License-Identifier value.
-    # REUSE-IgnoreStart
-    string(APPEND generated "//     __ _____ _____ _____\n")
-    string(APPEND generated "//  __|  |   __|     |   | |  JSON for Modern C++\n")
-    string(APPEND generated "// |  |  |__   |  |  | | | |  version 3.12.0\n")
-    string(APPEND generated "// |_____|_____|_____|_|___|  https://github.com/nlohmann/json\n")
-    string(APPEND generated "//\n")
-    string(APPEND generated "// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>\n")
-    string(APPEND generated "// SPDX-License-Identifier: MIT\n")
-    # REUSE-IgnoreEnd
-    string(APPEND generated "\n")
-    string(APPEND generated "#pragma once\n")
-    string(APPEND generated "\n")
-    foreach(name IN LISTS macro_names)
-        string(APPEND generated "#undef ${name}\n")
-    endforeach()
-else()
-    string(APPEND generated "// This file is generated by cmake/scripts/gen_hedley_undef_check.cmake\n")
-    string(APPEND generated "// from include/nlohmann/thirdparty/hedley/hedley.hpp. Do not edit it by\n")
-    string(APPEND generated "// hand -- it is regenerated on every build. ${macro_count} macros checked.\n\n")
-    foreach(name IN LISTS macro_names)
-        string(APPEND generated "#ifdef ${name}\n")
-        string(APPEND generated "    FAIL_CHECK(\"${name} leaked after including nlohmann/json.hpp\");\n")
-        string(APPEND generated "#endif\n")
-    endforeach()
-endif()
-
-get_filename_component(output_dir "${OUTPUT}" DIRECTORY)
-if(output_dir)
-    file(MAKE_DIRECTORY "${output_dir}")
-endif()
-
-# Avoid rewriting the file (and busting downstream incremental rebuilds)
-# when the content has not actually changed.
-set(write_output TRUE)
-if(EXISTS "${OUTPUT}")
-    file(READ "${OUTPUT}" existing_content)
-    if(existing_content STREQUAL generated)
-        set(write_output FALSE)
-    endif()
-endif()
-if(write_output)
-    file(WRITE "${OUTPUT}" "${generated}")
-endif()
@@ -14,11 +14,7 @@ To store objects in C++, a type is defined by the template parameters explained
 ## Template parameters

 `ArrayType`
-:   container type to store arrays. It must be a vector-like container: the library uses `operator[]`, `at()`, and
-    `resize()`, and requires random-access iterators. `#!cpp std::vector` and `#!cpp std::deque` qualify;
-    `#!cpp std::list` does not. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#arraytype) for the full list of
-    requirements.
+:   container type to store arrays (e.g., `std::vector` or `std::list`)

 `AllocatorType`
 :   the allocator to use for objects (e.g., `std::allocator`)
@@ -70,4 +66,3 @@ Arrays are stored as pointers in a `basic_json` type. That is, for any access to
 ## Version history

 - Added in version 1.0.0.
- Made `capacity()` optional, so that array types such as `#!cpp std::deque` can be used, in version 3.13.0.
@@ -42,9 +42,7 @@ represent a byte array in modern C++.
    `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`. The elements must be stored contiguously, and
-    the binary readers additionally require `resize()` and `operator[]`. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#binarytype) for the full list.
+    `#!cpp std::vector<std::intptr_t>` will not work as `BinaryType`.

 ## Notes

@@ -52,11 +50,6 @@ represent a byte array in modern C++.

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

-#### Supported byte types
-
-`#!cpp std::vector<std::uint8_t>`, `#!cpp std::vector<char>`, and `#!cpp std::vector<std::byte>` are supported.
-Regardless of which of them is configured, [`dump`](dump.md) writes the bytes as the numbers 0..255.
-
 #### Custom BinaryType behavior

 When a custom `BinaryType` is configured (other than the default `#!cpp std::vector<std::uint8_t>`), you can assign
@@ -133,6 +126,3 @@ type `#!cpp binary_t*` must be dereferenced.
 ## Version history

 - Added in version 3.8.0. Changed the type of subtype to `std::uint64_t` in version 3.10.0.
- Fixed [`dump`](dump.md), [`std::hash`](std_hash.md), and [`to_ubjson`](to_ubjson.md) for byte types that are not
-  integers (e.g., `#!cpp std::byte`) in version 3.13.0. `dump` now writes the bytes of a signed byte type (e.g.,
-  `#!cpp char`) as 0..255 rather than as negative numbers.
@@ -11,14 +11,6 @@ literals `#!json true` and `#!json false`.

 To store boolean values in C++, a type is defined by the template parameter  `BooleanType` which chooses the type to use.

-## Template parameters
-
-`BooleanType`
-:   the type to store booleans. As it is stored directly inside a `basic_json` value (in a union), it must be a
-    trivially default-constructible, trivially copyable, and trivially destructible type that is convertible to and
-    from `#!cpp bool`. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#booleantype).
-
 ## Notes

 #### Default type
@@ -35,10 +35,6 @@ class basic_json;
 | `BinaryType`         | type for binary arrays                                                    | [`binary_t`](binary_t.md)                   |
 | `CustomBaseClass`    | extension point for user code                                             | [`json_base_class_t`](json_base_class_t.md) |

-The library imposes a number of requirements on these types that are not expressed as C++ concepts, such as the
-container operations `object_t` and `array_t` must provide, or the fact that `StringType` must be `char`-based. They
-are collected in [Template Parameter Requirements](../../features/types/template_parameters.md).
-
 ## Specializations

 - [**json**](../json.md) - default specialization
@@ -21,11 +21,8 @@ The default value for `CustomBaseClass` is `void`. In this case, an

 #### Limitations

-The type `CustomBaseClass` has to be a default-constructible, non-`final` class.
+The type `CustomBaseClass` has to be a default-constructible class.
 `basic_json` only supports copy/move construction/assignment if `CustomBaseClass` does so as well.
-A `CustomBaseClass` with non-static data members forfeits `basic_json`'s
-[standard layout](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType) guarantee. See
-[Template Parameter Requirements](../../features/types/template_parameters.md#custombaseclass).

 ## Examples

@@ -19,12 +19,6 @@ using json_serializer = JSONSerializer<T, SFINAE>;

 The default values for `json_serializer` is [`adl_serializer`](../adl_serializer/index.md).

-#### Requirements
-
-A custom serializer must provide `#!cpp static void to_json(basic_json&, T)` for every type it serializes, and either
-`#!cpp static void from_json(const basic_json&, T&)` or `#!cpp static T from_json(const basic_json&)` for every type it
-deserializes. See [Template Parameter Requirements](../../features/types/template_parameters.md#jsonserializer).
-
 ## Examples

 ??? example
@@ -20,16 +20,6 @@ used.
 To store floating-point numbers in C++, a type is defined by the template parameter `NumberFloatType` which chooses the
 type to use.

-## Template parameters
-
-`NumberFloatType`
-:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
-    [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
-    because they have no encoding for `#!cpp long double`. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
-
 ## Notes

 #### Default type
@@ -20,13 +20,6 @@ used.
 To store integer numbers in C++, a type is defined by the template parameter `NumberIntegerType` which chooses the type
 to use.

-## Template parameters
-
-`NumberIntegerType`
-:   the type to store signed integers. It must be a **signed integral** type (`#!cpp std::is_integral`) with a
-    `#!cpp std::numeric_limits` specialization, and it is stored directly inside a `basic_json` value. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#numberintegertype-and-numberunsignedtype).
-
 ## Notes

 #### Default type
@@ -20,14 +20,6 @@ used.
 To store unsigned integer numbers in C++, a type is defined by the template parameter `NumberUnsignedType` which chooses
 the type to use.

-## Template parameters
-
-`NumberUnsignedType`
-:   the type to store unsigned integers. It must be an **unsigned integral** type (`#!cpp std::is_integral`) with a
-    `#!cpp std::numeric_limits` specialization, and it must be able to represent the absolute value of every
-    [`number_integer_t`](number_integer_t.md) value. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#numberintegertype-and-numberunsignedtype).
-
 ## Notes

 #### Default type
@@ -30,5 +30,3 @@ and [`default_object_comparator_t`](default_object_comparator_t.md) otherwise.
 - Added in version 3.0.0.
 - Changed to be conditionally defined as `#!cpp typename object_t::key_compare` or `default_object_comparator_t` in
  version 3.11.0.
- Fixed the fallback to `default_object_comparator_t`, which previously failed to compile for object types without a
-  `key_compare` member type, in version 3.13.0.
@@ -18,11 +18,7 @@ To store objects in C++, a type is defined by the template parameters described
 ## Template parameters

 `ObjectType`
-:   the container to store objects. Its template parameters must have the same order and meaning as those of
-    `std::map`; in particular, the third parameter is a comparator. `#!cpp std::unordered_map`, whose third parameter
-    is a hash function, therefore needs an adapter -- see
-    [Template Parameter Requirements](../../features/types/template_parameters.md#objecttype) for the full list of
-    requirements, an adapter example, and the containers that are known to work.
+:   the container to store objects (e.g., `std::map` or `std::unordered_map`)

 `StringType`
 :   the type of the keys or names (e.g., `std::string`). The comparison function `std::less<StringType>` is used to
@@ -126,4 +122,3 @@ the object is silently converted as an array of key-value pairs, which is incorr
 ## Version history

 - Added in version 1.0.0.
- Allowed object types whose `erase(iterator)` returns `#!cpp void` in version 3.13.0.
@@ -34,10 +34,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
- Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
-  location has a parent that is neither an object nor an array.
- Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
-  location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
  unsuccessful.

@@ -79,7 +75,3 @@ is thrown. In any case, the original value is not changed: the patch is applied
 - Added in version 2.0.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
  target location has a non-object/non-array parent in version 3.13.0.
- Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
-  location has a non-object/non-array parent in version 3.13.0.
- Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
-  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
@@ -30,10 +30,6 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
  location has a parent that is neither an object nor an array.
- Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target
-  location has a parent that is neither an object nor an array.
- Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
-  location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
  unsuccessful.

@@ -76,7 +72,3 @@ function throws an exception.
 - Added in version 3.11.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
  target location has a non-object/non-array parent in version 3.13.0.
- Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
-  location has a non-object/non-array parent in version 3.13.0.
- Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
-  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
@@ -23,11 +23,6 @@ JSON class into byte-sized characters during deserialization.
    `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.

-    Beyond the character type, the library expects a substantial part of the `#!cpp std::string` interface (contiguous
-    null-terminated `data()`, `substr()`, `find()`, `append()`, ...). See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#stringtype) for the full list and
-    for the string types that are known to work.
-
 ## Notes

 #### Default type
@@ -83,5 +78,3 @@ and an example.
 ## Version history

 - Added in version 1.0.0.
- Removed the requirement that `string_t` be implicitly convertible from `#!cpp std::string`, which the BSON writer and
-  the UBJSON reader relied on, in version 3.13.0.
@@ -34,14 +34,10 @@ void swap(typename binary_t::container_type& other);
 ```

 1. Exchanges the contents of the JSON value with those of `other`. Does not invoke any move, copy, or swap operations on
-   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. If macro
-   [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) is defined to `#!cpp 1`, the
-   [`start_pos()`](start_pos.md)/[`end_pos()`](end_pos.md) diagnostic positions are exchanged along with the value.
+   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. 
 2. Exchanges the contents of the JSON value from `left` with those of `right`. Does not invoke any move, copy, or swap
   operations on individual elements. All iterators and references remain valid. The past-the-end iterator is
-   invalidated. Implemented as a friend function callable via ADL. If macro
-   [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) is defined to `#!cpp 1`, the
-   [`start_pos()`](start_pos.md)/[`end_pos()`](end_pos.md) diagnostic positions are exchanged along with the value.
+   invalidated. Implemented as a friend function callable via ADL.
 3. Exchanges the contents of a JSON array with those of `other`. Does not invoke any move, copy, or swap operations on
   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. 
 4. Exchanges the contents of a JSON object with those of `other`. Does not invoke any move, copy, or swap operations on
@@ -37,14 +37,7 @@ Linear in the size of the JSON value.
 ## Notes

 Empty objects and arrays are flattened by [`flatten()`](flatten.md) to `#!json null` values and cannot unflattened to
-their original type.
-
-A flattened array and a flattened object whose keys are array indices are indistinguishable, because both are
-described by the same JSON pointers. A value is therefore restored as an array if and only if one of its keys is the
-reference token `0`, and as an object otherwise: `#!json {"2": 1}` is restored unchanged, whereas `#!json {"0": 1}` is
-restored as `#!json [1]`. This decision does not depend on the order in which the flattened object is iterated.
-
-Apart from these two cases, for a JSON value `j`, the following is always true:
+their original type. Apart from this example, for a JSON value `j`, the following is always true:
 `#!cpp j == j.flatten().unflatten()`.

 ## Examples
@@ -70,4 +63,3 @@ Apart from these two cases, for a JSON value `j`, the following is always true:
 ## Version history

 - Added in version 2.0.0.
- Made the array/object decision independent of the object's iteration order in version 3.13.0.
@@ -24,7 +24,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
- [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation

 ## Library version

@@ -12,11 +12,9 @@
 Controls how exceptions are handled by the library.

 1. This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/try_catch) calls inside the library.
-   The argument is the type of the exception to catch. The library uses it in a single place: to swallow any exception
-   escaping the parent-pointer check that [`JSON_DIAGNOSTICS`](json_diagnostics.md) adds to the class invariant. The
-   places where the library catches its own [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions
-   use `JSON_INTERNAL_CATCH` instead, which `JSON_CATCH_USER` also overrides unless `JSON_INTERNAL_CATCH_USER` is
-   defined. The macro is always followed by a scope.
+   The argument is the type of the exception to catch. As of version 3.8.0, the library only catches `std::out_of_range`
+   exceptions internally to rethrow them as [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions.
+   The macro is always followed by a scope.
 2. This macro overrides `#!cpp throw` calls inside the library. The argument is the exception to be thrown. Note that
   `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield
   undefined behavior.
@@ -1,71 +0,0 @@
-# JSON_USE_SIMDUTF
-
-```cpp
-#define JSON_USE_SIMDUTF
-```
-
-When defined, the parser validates the UTF-8 content of JSON strings that come from a **contiguous byte input**
-(`std::string`, `std::vector<char>`/`<std::uint8_t>`, string literals, `const char*` ranges, …) using the
-[simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. On text with many
-non-ASCII characters (e.g. CJK or emoji) this can validate several times faster.
-
-This is an **opt-in external dependency**. The library itself remains header-only and its behavior is unchanged: the
-same input is accepted or rejected either way, and every parse error is reported at the same position with the same
-message (simdutf is only used to fast-path *valid* runs; anything it flags falls back to the scalar path so the exact
-diagnostic is preserved). Streaming inputs (files, `std::istream`, wide strings, user-defined adapters) always use the
-scalar path.
-
-When `JSON_USE_SIMDUTF` is defined you must make the `simdutf.h` header available on the include path and link the
-simdutf library. When it is not defined, no simdutf header is included and there is no dependency.
-
-!!! note "Requires C++17"
-
-    simdutf requires C++17 and its header rejects older standards with an `#!cpp #error`. The backend is therefore only
-    compiled in from C++17 on. In C++11 and C++14 the macro has no effect and the scalar validator is used, which
-    accepts and rejects exactly the same input -- only throughput differs. Setting the macro project-wide is therefore
-    safe even when some translation units are built with an older standard.
-
-!!! warning "Define consistently"
-
-    The macro selects between two definitions of the same inline validation function. It must therefore be defined
-    identically for **every** translation unit that includes the library; mixing translation units that define it with
-    ones that do not is an ODR violation. Prefer setting it as a compile definition on the target rather than with
-    `#!cpp #define` in individual source files.
-
-## Default definition
-
-By default, `#!cpp JSON_USE_SIMDUTF` is not defined and the portable C++11 scalar validator is used.
-
-```cpp
-#undef JSON_USE_SIMDUTF
-```
-
-## Examples
-
-??? example
-
-    The code below enables the simdutf backend for UTF-8 validation.
-
-    ```cpp
-    #define JSON_USE_SIMDUTF 1
-    #include <nlohmann/json.hpp>
-
-    ...
-    ```
-
-    The project must also link against simdutf, e.g. with CMake:
-
-    ```cmake
-    target_compile_definitions(your_target PRIVATE JSON_USE_SIMDUTF)
-    target_link_libraries(your_target PRIVATE simdutf::simdutf)
-    ```
-
-!!! hint "Testing this configuration"
-
-    The unit tests can be built against the simdutf backend with the CMake option `JSON_TestSimdutf` (`OFF` by
-    default), which fetches simdutf and defines `JSON_USE_SIMDUTF` for every test target. The `ci_test_simdutf` target
-    runs the whole test suite in that configuration.
-
-## Version history
-
- Added in version 3.13.0.
@@ -1,19 +0,0 @@
-#include <iostream>
-#include <map>
-
-#include <nlohmann/json.hpp>
-
-#include "custom_array_type.hpp"
-
-using custom_json = nlohmann::basic_json<std::map, custom_array_type>;
-
-int main()
-{
-    custom_json j = custom_json::array();
-    j.push_back(1);
-    j.push_back(2);
-    j.push_back(3);
-
-    std::cout << j.dump() << std::endl;
-    std::cout << std::boolalpha << (custom_json::parse(j.dump()) == j) << std::endl;
-}
@@ -1,152 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-// A minimal, self-contained ArrayType built around a private std::vector.
-// See https://json.nlohmann.me/features/types/template_parameters/#arraytype
-template<class T, class Allocator = std::allocator<T>>
-class custom_array_type
-{
-    using vector_t = std::vector<T, Allocator>;
-    vector_t data_;
-
-  public:
-    using value_type = typename vector_t::value_type;
-    using size_type = typename vector_t::size_type;
-    using iterator = typename vector_t::iterator;
-    using const_iterator = typename vector_t::const_iterator;
-
-    custom_array_type() = default;
-    custom_array_type(const custom_array_type&) = default;
-    custom_array_type(custom_array_type&&) = default;
-    custom_array_type& operator=(const custom_array_type&) = default;
-    custom_array_type& operator=(custom_array_type&&) = default;
-
-    template<class InputIt>
-    custom_array_type(InputIt first, InputIt last) : data_(first, last) {}
-
-    custom_array_type(size_type count, const T& value) : data_(count, value) {}
-
-    iterator begin()
-    {
-        return data_.begin();
-    }
-    iterator end()
-    {
-        return data_.end();
-    }
-    const_iterator begin() const
-    {
-        return data_.begin();
-    }
-    const_iterator end() const
-    {
-        return data_.end();
-    }
-    const_iterator cbegin() const
-    {
-        return data_.cbegin();
-    }
-    const_iterator cend() const
-    {
-        return data_.cend();
-    }
-
-    bool empty() const
-    {
-        return data_.empty();
-    }
-    size_type size() const
-    {
-        return data_.size();
-    }
-    size_type max_size() const
-    {
-        return data_.max_size();
-    }
-    void clear()
-    {
-        data_.clear();
-    }
-    void resize(size_type n)
-    {
-        data_.resize(n);
-    }
-
-    T& operator[](size_type pos)
-    {
-        return data_[pos];
-    }
-    const T& operator[](size_type pos) const
-    {
-        return data_[pos];
-    }
-
-    T& back()
-    {
-        return data_.back();
-    }
-    const T& back() const
-    {
-        return data_.back();
-    }
-
-    void push_back(const T& value)
-    {
-        data_.push_back(value);
-    }
-    void push_back(T&& value)
-    {
-        data_.push_back(std::move(value));
-    }
-
-    template<class... Args>
-    void emplace_back(Args&& ... args)
-    {
-        data_.emplace_back(std::forward<Args>(args)...);
-    }
-
-    void pop_back()
-    {
-        data_.pop_back();
-    }
-
-    iterator insert(const_iterator pos, const T& value)
-    {
-        return data_.insert(pos, value);
-    }
-    iterator insert(const_iterator pos, size_type count, const T& value)
-    {
-        return data_.insert(pos, count, value);
-    }
-    template<class InputIt>
-    iterator insert(const_iterator pos, InputIt first, InputIt last)
-    {
-        return data_.insert(pos, first, last);
-    }
-
-    iterator erase(const_iterator pos)
-    {
-        return data_.erase(pos);
-    }
-    iterator erase(const_iterator first, const_iterator last)
-    {
-        return data_.erase(first, last);
-    }
-
-    void swap(custom_array_type& other)
-    {
-        data_.swap(other.data_);
-    }
-
-    friend bool operator==(const custom_array_type& lhs, const custom_array_type& rhs)
-    {
-        return lhs.data_ == rhs.data_;
-    }
-    friend bool operator<(const custom_array_type& lhs, const custom_array_type& rhs)
-    {
-        return lhs.data_ < rhs.data_;
-    }
-};
@@ -1,2 +0,0 @@
-[1,2,3]
-true
@@ -1,21 +0,0 @@
-#include <cstdint>
-#include <iostream>
-#include <map>
-#include <string>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-#include "custom_binary_type.hpp"
-
-using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool,
-      std::int64_t, std::uint64_t, double, std::allocator,
-      nlohmann::adl_serializer, custom_binary_type>;
-
-int main()
-{
-    const auto j = custom_json::binary({0x01, 0x02, 0x03});
-
-    std::cout << j.dump() << std::endl;
-    std::cout << std::boolalpha << (custom_json::from_cbor(custom_json::to_cbor(j)) == j) << std::endl;
-}
@@ -1,112 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <initializer_list>
-#include <vector>
-
-// A minimal, self-contained BinaryType built around a private std::vector.
-// See https://json.nlohmann.me/features/types/template_parameters/#binarytype
-class custom_binary_type
-{
-    using vector_t = std::vector<std::uint8_t>;
-    vector_t data_;
-
-  public:
-    using value_type = vector_t::value_type;
-    using size_type = vector_t::size_type;
-    using iterator = vector_t::iterator;
-    using const_iterator = vector_t::const_iterator;
-
-    custom_binary_type() = default;
-    custom_binary_type(const custom_binary_type&) = default;
-    custom_binary_type(custom_binary_type&&) = default;
-    custom_binary_type& operator=(const custom_binary_type&) = default;
-    custom_binary_type& operator=(custom_binary_type&&) = default;
-
-    template<class InputIt>
-    custom_binary_type(InputIt first, InputIt last) : data_(first, last) {}
-
-    // so basic_json::binary({0x01, 0x02}) can build one directly
-    custom_binary_type(std::initializer_list<std::uint8_t> init) : data_(init) {}
-
-    size_type size() const
-    {
-        return data_.size();
-    }
-    bool empty() const
-    {
-        return data_.empty();
-    }
-    void clear()
-    {
-        data_.clear();
-    }
-    void resize(size_type n)
-    {
-        data_.resize(n);
-    }
-
-    // read-only is enough: the writers only ever read from a binary value
-    const std::uint8_t* data() const
-    {
-        return data_.data();
-    }
-
-    std::uint8_t& operator[](size_type pos)
-    {
-        return data_[pos];
-    }
-    std::uint8_t operator[](size_type pos) const
-    {
-        return data_[pos];
-    }
-
-    std::uint8_t& back()
-    {
-        return data_.back();
-    }
-    std::uint8_t back() const
-    {
-        return data_.back();
-    }
-
-    iterator begin()
-    {
-        return data_.begin();
-    }
-    iterator end()
-    {
-        return data_.end();
-    }
-    const_iterator begin() const
-    {
-        return data_.begin();
-    }
-    const_iterator end() const
-    {
-        return data_.end();
-    }
-    const_iterator cbegin() const
-    {
-        return data_.cbegin();
-    }
-    const_iterator cend() const
-    {
-        return data_.cend();
-    }
-
-    template<class InputIt>
-    iterator insert(const_iterator pos, InputIt first, InputIt last)
-    {
-        return data_.insert(pos, first, last);
-    }
-
-    friend bool operator==(const custom_binary_type& lhs, const custom_binary_type& rhs)
-    {
-        return lhs.data_ == rhs.data_;
-    }
-    friend bool operator<(const custom_binary_type& lhs, const custom_binary_type& rhs)
-    {
-        return lhs.data_ < rhs.data_;
-    }
-};
@@ -1,2 +0,0 @@
-{"bytes":[1,2,3],"subtype":null}
-true
@@ -1,26 +0,0 @@
-#include <iostream>
-#include <type_traits>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-#include "custom_object_type.hpp"
-
-using custom_json = nlohmann::basic_json<custom_object_type, std::vector>;
-
-int main()
-{
-    custom_json j;
-    j["pi"] = 3.141;
-    j["happy"] = true;
-    j["list"] = {1, 2, 3};
-
-    std::cout << j.dump(2) << std::endl;
-    std::cout << std::boolalpha << (custom_json::parse(j.dump()) == j) << std::endl;
-
-    // custom_object_type has no key_compare member, so object_comparator_t
-    // falls back to its default
-    std::cout << std::boolalpha
-              << std::is_same<custom_json::object_comparator_t, custom_json::default_object_comparator_t>::value
-              << std::endl;
-}
@@ -1,144 +0,0 @@
-#pragma once
-
-#include <map>
-#include <utility>
-
-// A minimal, self-contained ObjectType built around a private std::map.
-// key_compare is deliberately not exposed: when an ObjectType has no
-// key_compare member, the library falls back to its own default comparator.
-// See https://json.nlohmann.me/features/types/template_parameters/#objecttype
-template<class Key, class T, class Compare, class Allocator>
-class custom_object_type
-{
-    using map_t = std::map<Key, T, Compare, Allocator>;
-    map_t data_;
-
-  public:
-    using key_type = typename map_t::key_type;
-    using mapped_type = typename map_t::mapped_type;
-    using value_type = typename map_t::value_type;
-    using size_type = typename map_t::size_type;
-    using iterator = typename map_t::iterator;
-    using const_iterator = typename map_t::const_iterator;
-
-    custom_object_type() = default;
-    custom_object_type(const custom_object_type&) = default;
-    custom_object_type(custom_object_type&&) = default;
-    custom_object_type& operator=(const custom_object_type&) = default;
-    custom_object_type& operator=(custom_object_type&&) = default;
-
-    template<class InputIt>
-    custom_object_type(InputIt first, InputIt last) : data_(first, last) {}
-
-    iterator begin()
-    {
-        return data_.begin();
-    }
-    iterator end()
-    {
-        return data_.end();
-    }
-    const_iterator begin() const
-    {
-        return data_.begin();
-    }
-    const_iterator end() const
-    {
-        return data_.end();
-    }
-    const_iterator cbegin() const
-    {
-        return data_.cbegin();
-    }
-    const_iterator cend() const
-    {
-        return data_.cend();
-    }
-
-    bool empty() const
-    {
-        return data_.empty();
-    }
-    size_type size() const
-    {
-        return data_.size();
-    }
-    size_type max_size() const
-    {
-        return data_.max_size();
-    }
-    void clear()
-    {
-        data_.clear();
-    }
-
-    iterator find(const key_type& key)
-    {
-        return data_.find(key);
-    }
-    const_iterator find(const key_type& key) const
-    {
-        return data_.find(key);
-    }
-    size_type count(const key_type& key) const
-    {
-        return data_.count(key);
-    }
-
-    std::pair<iterator, bool> emplace(const key_type& key, const mapped_type& value)
-    {
-        return data_.emplace(key, value);
-    }
-
-    std::pair<iterator, bool> insert(const value_type& value)
-    {
-        return data_.insert(value);
-    }
-
-    template<class InputIt>
-    void insert(InputIt first, InputIt last)
-    {
-        data_.insert(first, last);
-    }
-
-    mapped_type& operator[](const key_type& key)
-    {
-        return data_[key];
-    }
-
-    mapped_type& at(const key_type& key)
-    {
-        return data_.at(key);
-    }
-    const mapped_type& at(const key_type& key) const
-    {
-        return data_.at(key);
-    }
-
-    iterator erase(iterator pos)
-    {
-        return data_.erase(pos);
-    }
-    iterator erase(iterator first, iterator last)
-    {
-        return data_.erase(first, last);
-    }
-    size_type erase(const key_type& key)
-    {
-        return data_.erase(key);
-    }
-
-    void swap(custom_object_type& other)
-    {
-        data_.swap(other.data_);
-    }
-
-    friend bool operator==(const custom_object_type& lhs, const custom_object_type& rhs)
-    {
-        return lhs.data_ == rhs.data_;
-    }
-    friend bool operator<(const custom_object_type& lhs, const custom_object_type& rhs)
-    {
-        return lhs.data_ < rhs.data_;
-    }
-};
@@ -1,11 +0,0 @@
-{
-  "happy": true,
-  "list": [
-    1,
-    2,
-    3
-  ],
-  "pi": 3.141
-}
-true
-true
@@ -1,20 +0,0 @@
-#include <iostream>
-#include <map>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-#include "custom_string_type.hpp"
-
-using custom_json = nlohmann::basic_json<std::map, std::vector, custom_string_type>;
-
-int main()
-{
-    custom_json j;
-    j["pi"] = 3.141;
-    j["happy"] = true;
-    j["list"] = {1, 2, 3};
-
-    std::cout << j.dump(2) << std::endl;
-    std::cout << std::boolalpha << (custom_json::parse(j.dump()) == j) << std::endl;
-}
@@ -1,134 +0,0 @@
-#pragma once
-
-#include <ostream>
-#include <string>
-
-// A minimal, self-contained StringType built around a private std::string.
-// Wraps rather than inherits, so it exposes exactly what the library needs
-// and nothing more of std::string's interface.
-//
-// Covers the "Always required" members, the extras needed for the binary
-// formats, and the extras needed for JSON Pointer / flatten / unflatten /
-// diff. Extending it further (e.g. for std::hash<basic_json> or to_bson) is
-// a matter of adding the extra members listed in the "Required for other
-// functionality" table.
-//
-// See https://json.nlohmann.me/features/types/template_parameters/#stringtype
-class custom_string_type
-{
-    std::string data_;
-
-  public:
-    using value_type = char;
-    using size_type = std::string::size_type;
-    using iterator = std::string::iterator;
-    using const_iterator = std::string::const_iterator;
-
-    static constexpr size_type npos = std::string::npos;
-
-    custom_string_type() = default;
-    custom_string_type(const custom_string_type&) = default;
-    custom_string_type(custom_string_type&&) = default;
-    custom_string_type& operator=(const custom_string_type&) = default;
-    custom_string_type& operator=(custom_string_type&&) = default;
-
-    // not explicit: the library relies on being able to hand it a string literal
-    custom_string_type(const char* s) : data_(s) {}
-    custom_string_type(const char* s, size_type count) : data_(s, count) {}
-    custom_string_type(size_type count, char ch) : data_(count, ch) {}
-
-    size_type size() const
-    {
-        return data_.size();
-    }
-    bool empty() const
-    {
-        return data_.empty();
-    }
-    void clear()
-    {
-        data_.clear();
-    }
-    void resize(size_type n)
-    {
-        data_.resize(n);
-    }
-    void resize(size_type n, char c)
-    {
-        data_.resize(n, c);
-    }
-    void reserve(size_type n)
-    {
-        data_.reserve(n);
-    }
-
-    // must stay null-terminated -- the parser hands this to std::strtoull &
-    // friends; std::string::data() has guaranteed that since C++11
-    const char* data() const
-    {
-        return data_.data();
-    }
-
-    void push_back(char c)
-    {
-        data_.push_back(c);
-    }
-
-    char& operator[](size_type pos)
-    {
-        return data_[pos];
-    }
-    char operator[](size_type pos) const
-    {
-        return data_[pos];
-    }
-
-    custom_string_type& append(const char* s, size_type count)
-    {
-        data_.append(s, count);
-        return *this;
-    }
-    custom_string_type& append(const custom_string_type& other)
-    {
-        data_.append(other.data_);
-        return *this;
-    }
-
-    size_type find_first_of(char c, size_type pos = 0) const
-    {
-        return data_.find_first_of(c, pos);
-    }
-
-    iterator begin()
-    {
-        return data_.begin();
-    }
-    iterator end()
-    {
-        return data_.end();
-    }
-    const_iterator begin() const
-    {
-        return data_.begin();
-    }
-    const_iterator end() const
-    {
-        return data_.end();
-    }
-
-    friend bool operator==(const custom_string_type& lhs, const custom_string_type& rhs)
-    {
-        return lhs.data_ == rhs.data_;
-    }
-    friend bool operator<(const custom_string_type& lhs, const custom_string_type& rhs)
-    {
-        return lhs.data_ < rhs.data_;
-    }
-
-    // not required by the library itself, but dump() returns a custom_string_type
-    // and this makes `std::cout << j.dump()` work as expected
-    friend std::ostream& operator<<(std::ostream& os, const custom_string_type& s)
-    {
-        return os << s.data_;
-    }
-};
@@ -1,10 +0,0 @@
-{
-  "happy": true,
-  "list": [
-    1,
-    2,
-    3
-  ],
-  "pi": 3.141
-}
-true
@@ -4,8 +4,8 @@
 Hello, world!
 1 2 3 4 5 

+string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
-string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
@@ -4,8 +4,8 @@
 Hello, world!
 1 2 3 4 5 

+string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
-string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
@@ -4,9 +4,9 @@
 Hello, world!
 1 2 3 4 5 

+string: "Hello, world!"
 number: {"floating-point":17.23,"integer":42}
 null: null
-string: "Hello, world!"
 boolean: true
 array: [1,2,3,4,5]
 [json.exception.type_error.302] type must be boolean, but is string
@@ -125,7 +125,6 @@ The library uses the following mapping from JSON values types to BJData types ac

    - `"_ArrayType_"` is one of `uint8`, `int8`, `uint16`, `int16`, `uint32`, `int32`, `uint64`, `int64`, `single`,
      `double`, `char`, or `byte`,
-    - `"_ArraySize_"` is an array, since the dimensions are written as the ND-array header's length,
    - every entry of `"_ArraySize_"` is a non-negative integer, and their product is representable as a `std::size_t`,
    - `"_ArrayData_"` holds exactly that many elements, and
    - every element of `"_ArrayData_"` is a number of the kind named by `"_ArrayType_"` (a floating-point number for
@@ -204,14 +203,6 @@ The library maps BJData types to JSON value types as follows:

    The mapping is **complete** in the sense that any BJData value can be converted to a JSON value.

-!!! warning "UTF-8 validation of string values"
-
-    BJData does not specify an encoding for its `string`/`char` types, but this library requires them to be valid
-    UTF-8, consistent with the rest of the library. The bytes of every such string (object keys included) are
-    validated at decode time, and ill-formed UTF-8 is rejected with a
-    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
-    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped.
-
 ??? example

    ```cpp
@@ -109,15 +109,6 @@ The library maps BSON record types to JSON value types as follows:
    If BSON input must be validated for strict specification compliance, validate it separately before passing it to
    `from_bson()`.

-!!! warning "UTF-8 validation of string values"
-
-    The BSON specification requires `string` values (type `0x02`) to be valid UTF-8. This library validates the
-    bytes of every such string at decode time and rejects ill-formed UTF-8 with a
-    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
-    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped. Element
-    (key) names and `binary` values (type `0x05`) are unaffected and are never validated, since they are read
-    byte-by-byte as a C string, or are not required to hold text, respectively.
-
 ??? example

    ```cpp
@@ -176,16 +176,6 @@ The library maps CBOR types to JSON value types as follows:

    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.

-!!! warning "UTF-8 validation of text strings"
-
-    [RFC 8949, Section 3.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-3.1) requires CBOR text strings
-    (major type 3) to be valid UTF-8. This library validates the bytes of every text string (object keys included) at
-    decode time and rejects ill-formed UTF-8 with a
-    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with
-    `allow_exceptions` set to `false`, a discarded value), rather than only failing later when the resulting value is
-    dumped. Byte strings (major type 2) are unaffected and are never validated, since they are not required to hold
-    text.
-
 !!! warning "Tagged items"

    Tagged items (0xC0..0xDB) will throw a parse error by default. They can be ignored by passing `cbor_tag_handler_t::ignore` to function `from_cbor`, in which case the tag is skipped and the enclosed data item is parsed on its own. They can be stored by passing `cbor_tag_handler_t::store` to function `from_cbor`. Note that no tag is ever interpreted: for instance, a text string tagged with tag 0 (date/time) stays a string.
@@ -136,14 +136,6 @@ The library maps MessagePack types to JSON value types as follows:

    Any MessagePack output created by `to_msgpack` can be successfully parsed by `from_msgpack`.

-!!! warning "UTF-8 validation of string values"
-
-    The MessagePack specification requires `str` values (`fixstr`, `str 8`, `str 16`, `str 32`) to be valid UTF-8.
-    This library validates the bytes of every such string (object keys included) at decode time and rejects
-    ill-formed UTF-8 with a [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or,
-    with `allow_exceptions` set to `false`, a discarded value), rather than only failing later when the resulting
-    value is dumped. `bin`/`ext`/`fixext` values are unaffected and are never validated, since they are not required
-    to hold text.

 ??? example

@@ -69,13 +69,6 @@ The library uses the following mapping from JSON values types to UBJSON types ac
    Note that `use_size = true` alone may result in larger representations - the benefit of this parameter is that the
    receiving side is immediately informed on the number of elements of the container.

-    An array whose type marker is `Z` (null), `T` (true) or `F` (false) stores no payload at all, because the marker
-    already is the value. Its declared count is therefore the only thing that decides how much memory the receiving side
-    allocates, and a handful of bytes can describe billions of elements. `from_ubjson` rejects such an array with
-    [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408) when the count exceeds 1,048,576
-    (`1 << 20`), and `to_ubjson` writes longer arrays of these types without the annotation, so any value it produces
-    can be read back.
-
 !!! info "Binary values"

    If the JSON data contains the binary type, the value stored is a list of integers, as suggested by the UBJSON
@@ -120,14 +113,6 @@ The library maps UBJSON types to JSON value types as follows:

    The mapping is **complete** in the sense that any UBJSON value can be converted to a JSON value.

-!!! warning "UTF-8 validation of string values"
-
-    UBJSON does not specify an encoding for its `string`/`char` types, but this library requires them to be valid
-    UTF-8, consistent with the rest of the library. The bytes of every such string (object keys included) are
-    validated at decode time, and ill-formed UTF-8 is rejected with a
-    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
-    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped.
-
 ??? example

    ```cpp
@@ -137,14 +137,6 @@ behavior is deprecated and switched off (`0`) by default.

 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).

-## `JSON_USE_SIMDUTF`
-
-When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the
-[simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. This is an opt-in
-external dependency and is not defined by default.
-
-See [full documentation of `JSON_USE_SIMDUTF`](../api/macros/json_use_simdutf.md).
-
 ## `NLOHMANN_DEFINE_TYPE_*(...)`, `NLOHMANN_DEFINE_DERIVED_TYPE_*(...)`

 The library defines 12 macros to simplify the serialization/deserialization of types. See the page on
@@ -51,11 +51,7 @@ If you do want to preserve the **insertion order**, you can use the type [`nlohm
    --8<-- "examples/ordered_json.output"
    ```

-Alternatively, [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) also preserves the insertion order and, unlike [`ordered_map`](../api/ordered_map.md), keeps a lookup index, so it does not have the quadratic cost described below. It is used through a small adapter ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
-
-If the order does not matter and you only want faster lookup, `boost::unordered_flat_map`, `absl::flat_hash_map`, `absl::node_hash_map`, and several other hash maps work through an adapter that restores the template argument order `basic_json` expects; see [Template Parameter Requirements](types/template_parameters.md#objecttype). Note these are *unordered*, not insertion-ordered.
-
-[`tsl::ordered_map`](https://github.com/Tessil/ordered-map) cannot be used: its iterators expose the mapped value as `const`, while `basic_json` needs to modify it in place.
+Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).

 The [`ordered_map`](../api/ordered_map.md) behind `nlohmann::ordered_json` is deliberately minimal and has no lookup
 index, so every key access is a linear scan and building an object of `n` keys costs O(n²). This is unnoticeable at
@@ -79,8 +79,7 @@ template<
    class NumberFloatType = double,
    template<typename U> class AllocatorType = std::allocator,
    template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer,
-    class BinaryType = std::vector<std::uint8_t>,
-    class CustomBaseClass = void
+    class BinaryType = std::vector<std::uint8_t>
 >
 class basic_json;
 ```
@@ -107,10 +106,6 @@ using number_float_t = NumberFloatType;
 using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
 ```

-Not every type can be passed for these template arguments: the library uses the resulting types in ways that imply a
-number of requirements, for instance that `StringType` is `char`-based or that `ArrayType` is vector-like. These
-requirements are collected in [Template Parameter Requirements](template_parameters.md).
-

 ## Objects

@@ -1,747 +0,0 @@
-# Template Parameter Requirements
-
-Class [`basic_json`](../../api/basic_json/index.md) is configurable through eleven template parameters. The library
-never formally states what a type passed for one of these parameters has to provide -- the requirements are implied by
-the way the library uses the resulting [`object_t`](../../api/basic_json/object_t.md),
-[`array_t`](../../api/basic_json/array_t.md), [`string_t`](../../api/basic_json/string_t.md), etc. This page collects
-these requirements so they do not have to be discovered by trial and error. Each section lists the concrete types
-that are known to work for that parameter and the ones that do not, checked against Boost 1.83, Abseil 20250127.0,
-Folly, EASTL 3.21, `ankerl::unordered_dense`, `phmap`, `gtl`, `robin_hood`, `tsl::ordered_map`, and Qt 6.
-
-## How to read this page
-
-Requirements are split into two groups:
-
- **Always required** -- needed to instantiate `basic_json` at all, or needed by functions that virtually every program
-  uses (construction, element access, [`dump`](../../api/basic_json/dump.md)).
- **Required for ...** -- only needed when a particular part of the API is instantiated. Member function templates are
-  only instantiated when they are used, so a type may be perfectly usable even though it does not satisfy these
-  requirements, as long as the corresponding functions are never called.
-
-!!! warning "Requirements are not checked"
-
-    Three requirements are checked with a `#!cpp static_assert`: the array iterator category, the width of
-    [`BinaryType`](#binarytype)'s `value_type`, and [`NumberUnsignedType`](#numberintegertype-and-numberunsignedtype)
-    being at least as wide as [`NumberIntegerType`](#numberintegertype-and-numberunsignedtype). The rest are not
-    diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside
-    the library. Four violations are not caught at compile time at all:
-
-    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers,
-      because the lexer hands the buffer to `#!cpp std::strtoull`/`#!cpp std::strtoll`/`#!cpp std::strtod`.
-    - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation,
-      and [`get_allocator()`](../../api/basic_json/get_allocator.md) each use a different default-constructed instance.
-    - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion
-      in a normal build, and only fail silently under `#!cpp NDEBUG`.
-
-## Overview
-
-| Template parameter                                                | Default                           | Notable substitutes                                                   |
-|-------------------------------------------------------------------|-----------------------------------|-----------------------------------------------------------------------|
-| [`ObjectType`](#objecttype)                                       | `std::map`                        | [`nlohmann::ordered_map`](../../api/ordered_map.md), Abseil hash maps |
-| [`ArrayType`](#arraytype)                                         | `std::vector`                     | `#!cpp std::deque`                                                    |
-| [`StringType`](#stringtype)                                       | `std::string`                     | `std::string`-like types over `char`                                  |
-| [`BooleanType`](#booleantype)                                     | `bool`                            | none worth using                                                      |
-| [`NumberIntegerType`](#numberintegertype-and-numberunsignedtype)  | `std::int64_t`                    | any signed integer type                                               |
-| [`NumberUnsignedType`](#numberintegertype-and-numberunsignedtype) | `std::uint64_t`                   | any unsigned integer type at least as wide as `NumberIntegerType`     |
-| [`NumberFloatType`](#numberfloattype)                             | `double`                          | `float` (`long double`: no binary formats)                            |
-| [`AllocatorType`](#allocatortype)                                 | `std::allocator`                  | stateless allocators                                                  |
-| [`JSONSerializer`](#jsonserializer)                               | `adl_serializer`                  | serializers with the same interface                                   |
-| [`BinaryType`](#binarytype)                                       | `#!cpp std::vector<std::uint8_t>` | `#!cpp std::vector<char>`                                             |
-| [`CustomBaseClass`](#custombaseclass)                             | `void`                            | any default-constructible class                                       |
-
-!!! warning "Third-party containers and incomplete types"
-
-    `object_t` is instantiated inside the definition of `basic_json` -- it is probed for a `key_compare` member to
-    form [`object_comparator_t`](../../api/basic_json/object_comparator_t.md) -- i.e. while `basic_json` is still an
-    incomplete type. `#!cpp std::map` is required by the standard to support incomplete mapped types; most
-    third-party maps are not, and inspecting the mapped type at class scope (for instance with
-    `#!cpp std::is_trivially_move_assignable`) makes them unusable as `ObjectType`, no matter how their template
-    arguments are adapted. This rules out `absl::btree_map`, `phmap::btree_map`, `gtl::btree_map`,
-    `robin_hood::unordered_node_map`, `folly::F14FastMap`, and `eastl::hash_map`.
-
-    `array_t` is only *named* in the class definition and is not instantiated until `basic_json` is complete, so an
-    `ArrayType` that inspects its value type at class scope is generally fine -- `boost::container::small_vector` and
-    `static_vector` both reject incomplete value types yet work here. `absl::InlinedVector` is the exception: the
-    `#!cpp std::is_trivially_move_assignable<basic_json>` it evaluates while instantiating itself re-enters the
-    library's own trait machinery mid-instantiation.
-
-!!! note "Folly requires C++20"
-
-    Folly's headers use `#!cpp consteval` and `#!cpp std::type_identity`, so any `basic_json` specialization that
-    names a Folly type has to be compiled as C++20 or later, whatever the rest of the library supports.
-
-## `ObjectType`
-
-`ObjectType` is instantiated as
-
-```cpp
-using object_t = ObjectType<StringType,                                    // key_type
-                            basic_json,                                    // mapped_type
-                            default_object_comparator_t,                   // key_compare
-                            AllocatorType<std::pair<const StringType,
-                                                    basic_json>>>;         // allocator_type
-```
-
-i.e., the template arguments follow the order and meaning of `std::map`.
-
-### Always required
-
- The template must be usable with **four** type arguments in the order shown above. The third argument is a
-  **comparator**; containers that expect something else in this position (e.g., a hash function) need an alias template
-  or wrapper -- see [Notes](#notes).
- An optional member type `key_compare`. If it is present it becomes
-  [`object_comparator_t`](../../api/basic_json/object_comparator_t.md); otherwise
-  [`default_object_comparator_t`](../../api/basic_json/default_object_comparator_t.md) is used.
- Member types `key_type`, `mapped_type`, `value_type`, and `iterator`.
- `value_type` must behave like `#!cpp std::pair<const key_type, mapped_type>`; the library accesses `.first` and
-  `.second` on it.
- `iterator` must be default-constructible and satisfy
-  [LegacyBidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator). The type returned
-  by `cbegin()`/`cend()` must satisfy the same requirements.
- Constructors: default, copy, move, and from an iterator range `(first, last)`.
- Member functions `begin()`, `end()`, `cbegin()`, `cend()`, `empty()`, `size()`, `max_size()`, `clear()`,
-  `find(key)`, `count(key)`, `emplace(key, value)`, `insert(value_type)`, `insert(first, last)`, `operator[](key)`,
-  `erase(iterator)`, and `erase(first, last)`. `erase(iterator)` may return the following iterator or `#!cpp void`;
-  in the latter case the library computes the successor itself, before erasing.
- `erase(key)` is **optional**: if the container does not provide one, the library falls back to `find(key)` followed
-  by `erase(iterator)`.
- `at(key)` is required only by [`to_ubjson`](../../api/basic_json/to_ubjson.md) and
-  [`to_bjdata`](../../api/basic_json/to_bjdata.md), but every container tried here provides it.
- `emplace` and `insert(value_type)` must return `#!cpp std::pair<iterator, bool>` and must have **unique-key**
-  semantics; multimaps cannot be used.
- The type must be swappable (via `std::swap` or an ADL `swap`).
- The comparison operators `==` and `<`; `!=`, `<=`, `>`, and `>=` are derived from them. Where the library uses
-  three-way comparison (C++20), `==` and `<=>` are required **instead** -- the six two-way operators do not satisfy
-  it. They implement [`basic_json`'s comparison operators](../../api/basic_json/operator_eq.md).
-
-### Required for heterogeneous key lookup
-
-The overloads of [`at`](../../api/basic_json/at.md), [`operator[]`](../../api/basic_json/operator%5B%5D.md),
-[`find`](../../api/basic_json/find.md), [`contains`](../../api/basic_json/contains.md),
-[`count`](../../api/basic_json/count.md), [`erase`](../../api/basic_json/erase.md), and
-[`value`](../../api/basic_json/value.md) that accept a key type other than `object_t::key_type` require
-
- a **transparent** comparator, i.e. [`object_comparator_t`](../../api/basic_json/object_comparator_t.md) has a member
-  type `is_transparent` (this is why the default comparator is `#!cpp std::less<>` since C++14), and
- corresponding heterogeneous `find`, `count`, `erase`, and `operator[]` overloads on the container.
-
-### Notes
-
-#### `std::unordered_map` needs an adapter
-
-`#!cpp std::unordered_map` cannot be passed directly: its third template parameter is a hash function, but
-`basic_json` passes a comparator in that position. An alias template or wrapper that restores the expected argument
-order makes it usable:
-
-```cpp
-template<class Key, class T, class IgnoredCompare, class Allocator>
-struct unordered_map_object
-    : std::unordered_map<Key, T, std::hash<Key>, std::equal_to<Key>, Allocator>
-{
-    using base_t = std::unordered_map<Key, T, std::hash<Key>, std::equal_to<Key>, Allocator>;
-    using base_t::base_t;
-};
-
-using unordered_json = nlohmann::basic_json<unordered_map_object>;
-```
-
-Whether `#!cpp std::unordered_map` can be instantiated at all depends on the standard library: `object_t` is formed
-while `basic_json` is still incomplete (see the warning above), and libstdc++ 9 needs the size of the mapped type to
-instantiate the hash map's node type, so the adapter does not compile there. Newer libstdc++ versions, and the hash
-maps listed below, do not have that problem.
-
-The adapter above works verbatim for Abseil's, Boost's, `phmap`'s and `gtl`'s hash maps, which all place the hash
-function third and take a `#!cpp std::pair<const Key, T>` allocator fifth. Two need a different adapter:
-
- `ankerl::unordered_dense` expects an allocator over `#!cpp std::pair<Key, T>` (non-const key), so the allocator has
-  to be rebound to that or dropped.
- `robin_hood`'s fifth parameter is the non-type `MaxLoadFactor100`, so its adapter must drop the allocator entirely.
-
-None of these hash maps defines `key_compare`, so all of them additionally rely on `object_comparator_t` falling back
-to [`default_object_comparator_t`](../../api/basic_json/default_object_comparator_t.md); see
-[`object_comparator_t`](../../api/basic_json/object_comparator_t.md).
-
-#### Abseil hash maps
-
-`absl::flat_hash_map` and `absl::node_hash_map` tolerate an incomplete value type, but they take a hash function as
-their third template argument. The same adapter as for `#!cpp std::unordered_map` makes them usable:
-
-```cpp
-template<class Key, class T, class IgnoredCompare, class Allocator>
-struct flat_hash_object
-    : absl::flat_hash_map<Key, T, absl::Hash<Key>, std::equal_to<Key>, Allocator>
-{
-    using base_t = absl::flat_hash_map<Key, T, absl::Hash<Key>, std::equal_to<Key>, Allocator>;
-    using base_t::base_t;
-};
-
-using flat_hash_json = nlohmann::basic_json<flat_hash_object>;
-```
-
-`absl::node_hash_map` keeps references to the mapped values valid across insertions; `absl::flat_hash_map` does not,
-which makes it behave like [`ordered_json`](../../api/ordered_json.md) with respect to
-[iterator invalidation](../../api/basic_json/index.md#iterator-invalidation). Both expose a `capacity()` member
-function, so [`JSON_DIAGNOSTICS`](../../api/macros/json_diagnostics.md) treats them conservatively and keeps the
-parent pointers correct either way.
-
-#### Iteration order
-
-The library never relies on the container's iteration order for correctness; it does determine the order in which
-object keys are serialized by [`dump`](../../api/basic_json/dump.md) and visited by
-[`items`](../../api/basic_json/items.md). See [Object Order](../object_order.md).
-
-#### `capacity()` marks a container as insertion-ordered
-
-With [`JSON_DIAGNOSTICS`](../../api/macros/json_diagnostics.md) enabled, the library detects insertion-ordered maps by
-probing for a `capacity()` member function (`nlohmann::ordered_map` inherits it from `std::vector`) and refreshes all
-parent pointers after every insertion. An `ObjectType` that happens to have a `capacity()` member is therefore treated
-conservatively -- this is correct, but slower.
-
-#### Key order and duplicate keys
-
-The library does not sort or de-duplicate keys itself; the behavior described in
-[`object_t`](../../api/basic_json/object_t.md) is entirely the behavior of the chosen container.
-
-!!! tip "Reference implementation"
-
-    `docs/mkdocs/docs/examples/custom_object_type.hpp` wraps a private `#!cpp std::map` and satisfies every
-    requirement above. It does not define `key_compare`, so `object_comparator_t` falls back to
-    [`default_object_comparator_t`](../../api/basic_json/default_object_comparator_t.md) -- a good starting point for
-    a custom `ObjectType`.
-
-    ```cpp
-    --8<-- "examples/custom_object_type.hpp"
-    ```
-
-??? example "Compiling and using it"
-
-    ```cpp
-    --8<-- "examples/custom_object_type.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/custom_object_type.output"
-    ```
-
-### Compatible containers
-
-| Container                                                                        | Notes                                                                         |
-|----------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
-| `#!cpp std::map` (default)                                                       |                                                                               |
-| [`nlohmann::ordered_map`](../../api/ordered_map.md)                              | used by [`ordered_json`](../../api/ordered_json.md); keeps insertion order    |
-| [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map)                     | keeps insertion order; adapter puts `fifo_map_compare` in the comparator slot |
-| `boost::container::map`, `boost::container::flat_map`                            | no adapter needed                                                             |
-| `#!cpp std::unordered_map`                                                       | through the adapter above; not with libstdc++ 9, see the note                 |
-| `boost::unordered_map`, `boost::unordered_flat_map`, `boost::unordered_node_map` | through the adapter above                                                     |
-| `absl::flat_hash_map`, `absl::node_hash_map`                                     | through the adapter above; `flat_hash_map` moves mapped values on rehash      |
-| `phmap::flat_hash_map`, `phmap::node_hash_map`, `gtl::flat_hash_map`             | through the adapter above                                                     |
-| `ankerl::unordered_dense::map` and `segmented_map`                               | adapter must rebind or drop the allocator                                     |
-| `robin_hood::unordered_flat_map`                                                 | adapter must drop the allocator                                               |
-| `folly::F14NodeMap`                                                              | through the adapter above; requires C++20, see the note above                 |
-| `folly::sorted_vector_map`                                                       | alias must drop the allocator, whose value type it disagrees on               |
-
-### Containers that cannot be used
-
-| Container                                                                | Reason                                                                                                              |
-|--------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------|
-| `absl::btree_map`, `phmap::btree_map`, `gtl::btree_map`                  | require a complete mapped type                                                                                      |
-| `robin_hood::unordered_node_map`, `folly::F14FastMap`, `eastl::hash_map` | require a complete mapped type                                                                                      |
-| `eastl::map`                                                             | EASTL iterators do not work with `#!cpp std::iterator_traits`                                                       |
-| `tsl::ordered_map`                                                       | its iterators expose the mapped value as `#!cpp const`                                                              |
-| `QMap`                                                                   | no `value_type` member type                                                                                         |
-| `QHash`                                                                  | its `value_type` is the mapped type rather than a key/value pair, and its iterators dereference to the mapped value |
-| `#!cpp std::multimap`, `#!cpp std::unordered_multimap`                   | `emplace` does not return `#!cpp std::pair<iterator, bool>`                                                         |
-
-## `ArrayType`
-
-`ArrayType` is instantiated as
-
-```cpp
-using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
-```
-
-### Always required
-
- The template must be usable with **two** type arguments (value type and allocator).
- Member types `value_type` and `iterator`.
- Constructors: default, copy, and move; and from an iterator range `(first, last)`.
- Member functions `begin()`, `end()`, `cbegin()`, `cend()`, `empty()`, `size()`, `max_size()`, `clear()`,
-  `operator[](size_type)`, `back()`, `push_back()`, `emplace_back()`, `pop_back()`, `resize()`,
-  `insert()` (single element, count, and range), `erase(pos)`, and `erase(first, last)`.
-  `basic_json::insert(pos, initializer_list)` goes through the range overload, so no initializer-list `insert` is
-  needed. `at(size_type)` is **not** required: [`basic_json::at(size_type)`](../../api/basic_json/at.md) checks the
-  index itself and then uses `operator[]`.
- `iterator` must be default-constructible, and it as well as the type returned by `cbegin()`/`cend()` must satisfy
-  [LegacyRandomAccessIterator](https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator).
-  A `#!cpp static_assert` only checks for
-  [LegacyBidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator), but
-  [`dump`](../../api/basic_json/dump.md) (`cend() - 1`),
-  [`erase(idx)`](../../api/basic_json/erase.md) (`begin() + idx`), and the random-access operations of
-  [`basic_json::iterator`](../../api/basic_json/begin.md) require random access.
- The comparison operators, as for [`ObjectType`](#objecttype): `==` and `<`, or `==` and `<=>` under C++20.
-
-### Required for individual functions
-
- A member type `value_type`, for [`to_bson`](../../api/basic_json/to_bson.md) of an array.
- A constructor from `(count, value)`, for
-  [`basic_json(size_type, const basic_json&)`](../../api/basic_json/basic_json.md).
- Swappability, via `#!cpp std::swap` or an ADL `swap`, for [`swap(array_t&)`](../../api/basic_json/swap.md).
-
-!!! note "`capacity()` is optional"
-
-    With [`JSON_DIAGNOSTICS`](../../api/macros/json_diagnostics.md) enabled, the library reads `array_t::capacity()`
-    to find out whether adding an element reallocated the array and moved its elements, which would invalidate the
-    parent pointers. An array type without a `capacity()` member function is handled conservatively: the parent
-    pointers of all elements are refreshed after every insertion, which makes adding *n* elements cost O(*n*²). Only
-    diagnostics builds pay this; without them `capacity()` is never called.
-
-!!! tip "Reference implementation"
-
-    `docs/mkdocs/docs/examples/custom_array_type.hpp` wraps a private `#!cpp std::vector` and satisfies every
-    requirement above -- a good starting point for a custom `ArrayType`.
-
-    ```cpp
-    --8<-- "examples/custom_array_type.hpp"
-    ```
-
-??? example "Compiling and using it"
-
-    ```cpp
-    --8<-- "examples/custom_array_type.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/custom_array_type.output"
-    ```
-
-### Compatible containers
-
-| Container                                               | Notes                                                                                     |
-|---------------------------------------------------------|-------------------------------------------------------------------------------------------|
-| `#!cpp std::vector` (default)                           |                                                                                           |
-| `#!cpp std::deque`                                      | references survive appends, but not insertions elsewhere; see the `capacity()` note above |
-| `#!cpp std::pmr::vector`                                | through an alias, as the allocator comes from `AllocatorType` instead                     |
-| `boost::container::vector`, `deque`, `devector`         |                                                                                           |
-| `boost::container::stable_vector`                       | the only one tried that keeps references valid across *every* insertion                   |
-| `boost::container::small_vector`, `folly::small_vector` | through an alias that fixes the inline capacity                                           |
-| `boost::container::static_vector`                       | through the same kind of alias, for arrays that stay within the fixed capacity            |
-| `folly::fbvector`                                       | requires C++20, see the note above                                                        |
-
-### Containers that cannot be used
-
-| Container                           | Reason                                                                                        |
-|-------------------------------------|-----------------------------------------------------------------------------------------------|
-| `#!cpp std::list`                   | no `operator[]`, and no random-access iterators                                               |
-| `eastl::vector`, `QList`, `QVector` | no `max_size()`; they handle the incomplete value type fine                                   |
-| `absl::InlinedVector`               | requires a complete value type, see the note above                                            |
-| `absl::FixedArray`                  | the size is fixed at construction, so `resize`, `push_back`, `insert` and `erase` are missing |
-
-## `StringType`
-
-`StringType` is used **both** for JSON string values and for the keys of JSON objects
-(`string_t` and `object_t::key_type`).
-
-### Always required
-
- A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8
-  encoded `char` data and hands `data()` to `#!cpp std::strtoull`/`#!cpp std::strtoll`.
-  `#!cpp std::wstring`, `#!cpp std::u16string`, and `#!cpp std::u32string` are **not** valid choices; see the FAQ on
-  [wide string handling](../../home/faq.md#wide-string-handling).
- Constructors: default, copy, move, from `#!cpp const char*` (which must not be `#!cpp explicit`), from
-  `#!cpp (const char*, size_type)`, and from `#!cpp (size_type, char)`; and copy or move assignment.
- Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]`
-  (const and non-const, returning references). `c_str()` and `back()` are **not** required.
- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser hands it to
-  `#!cpp std::strtoull`. A type whose `data()` is not null-terminated does not fail to compile; it silently
-  misparses numbers.
- `append(const char*, size_type)`, used by [`dump`](../../api/basic_json/dump.md), and `append(const StringType&)`,
-  used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has
-  to append a `#!cpp char` and a `#!cpp const char*`; for each it selects between `append(arg)`, `#!cpp operator+=`,
-  `append(first, last)`, and `append(data, size)`.
- The comparison operator `==` against another `StringType`, and `<` for use as a key of the chosen
-  [`ObjectType`](#objecttype) (with the default comparator, `#!cpp std::less<>` must be able to compare two
-  `StringType` values, and a `StringType` with the key types used for lookup). `!=` is never applied to a
-  `StringType`, and `==` against `#!cpp const char*` is resolved by the implicit `#!cpp const char*` constructor.
-
-### Required for the binary formats
-
- `resize(n)`, used by the readers to make room for a block of bytes.
- Non-const `operator[]`, into which the readers `#!cpp std::memcpy` those bytes. A non-`#!cpp const` `data()` would
-  serve just as well, but `#!cpp std::string` has only had one since C++17, and the library still supports C++11.
-
-### Required for JSON Pointer, `flatten`, and `diff`
-
- A static member `npos` and the member function `find_first_of(char, size_type)` -- together with `data()`,
-  `reserve(n)`, and `append(const char*, size_type)` they implement the escaping and unescaping of reference tokens
-  described in RFC 6901. Neither `find(const StringType&, size_type)`, nor `substr(pos, count)`, nor
-  `replace(pos, count, const StringType&)` is required.
- `empty()`.
- `begin()` and `end()` -- used by
-  [`operator[](const json_pointer&)`](../../api/basic_json/operator%5B%5D.md) to decide whether a reference token
-  denotes an array index.
-
-### Required for other functionality
-
-| Functionality                                                                                                                     | Additional requirement                                                                                                                                                                       |
-|-----------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [`diff`](../../api/basic_json/diff.md), [`items`](../../api/basic_json/items.md), [`std::hash`](../../api/basic_json/std_hash.md) | conversion of a `#!cpp std::size_t` to `StringType`: either assignability from the result of `#!cpp std::to_string`, or an ADL overload `#!cpp void int_to_string(StringType&, std::size_t)` |
-| [`std::hash<basic_json>`](../../api/basic_json/std_hash.md)                                                                       | additionally a specialization of `#!cpp std::hash<StringType>`                                                                                                                               |
-| [`to_bson`](../../api/basic_json/to_bson.md)                                                                                      | `find(value_type)` and `npos`                                                                                                                                                                |
-| [`parse`](../../api/basic_json/parse.md) from a `string_t`                                                                        | the input adapters must accept it; otherwise pass a character range                                                                                                                          |
-| `#!cpp operator<<(std::ostream&, const json_pointer&)`                                                                            | streamability to `#!cpp std::ostream`                                                                                                                                                        |
-| exception messages                                                                                                                | `data()` and `size()`, or `begin()` and `end()`                                                                                                                                              |
-
-### Compatible types
-
-| Type                                                            | Notes                                                                                                                                                                                                                                         |
-|-----------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `#!cpp std::string` (default)                                   |                                                                                                                                                                                                                                               |
-| `#!cpp std::basic_string` with a custom **stateless** allocator |                                                                                                                                                                                                                                               |
-| `#!cpp std::pmr::string`                                        | see the warning below before relying on the memory resource                                                                                                                                                                                   |
-| `boost::container::string`                                      | needs a user-supplied `#!cpp std::hash` specialization (Boost provides `boost::hash` instead)                                                                                                                                                 |
-| `folly::fbstring`                                               | requires C++20, see the note above                                                                                                                                                                                                            |
-| `eastl::string`                                                 | needs a user-supplied `#!cpp std::hash` and an ADL `int_to_string` (it is not assignable from a `#!cpp std::string`); [`parse`](../../api/basic_json/parse.md) does not accept it directly -- pass a character range or a `#!cpp std::string` |
-| a custom string class in a user-defined namespace               | if the requirements above are met                                                                                                                                                                                                             |
-
-### Types that cannot be used
-
-| Type                                                                 | Reason                                                                                                  |
-|----------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|
-| `#!cpp std::wstring`, `#!cpp std::u16string`, `#!cpp std::u32string` | the character type is not one byte wide                                                                 |
-| `#!cpp std::u8string`                                                | one byte wide, but `#!cpp char8_t` is not `#!cpp char`-compatible                                       |
-| `absl::Cord`                                                         | no `value_type`, and the storage is not contiguous                                                      |
-| `QString`                                                            | no `append(const char*, size_type)`; its `QChar` is also two bytes wide, though that is never diagnosed |
-
-!!! warning "A `std::pmr::string` mostly does not use the memory resource you choose"
-
-    `basic_json` cannot be given an allocator or a memory resource. `AllocatorType` is default-constructed at every
-    allocation and has to be stateless (see [`AllocatorType`](#allocatortype)), and string values the library creates
-    are constructed with their own default allocator. So:
-
-    - Every string the library itself produces -- from [`parse`](../../api/basic_json/parse.md), from
-      [`dump`](../../api/basic_json/dump.md), or by default construction -- allocates from
-      `#!cpp std::pmr::get_default_resource()`.
-    - **Copying** an arena-backed string into a value silently drops its memory resource: the copy lands on the
-      default resource, because `#!cpp std::pmr::polymorphic_allocator` does not propagate on copy construction.
-      Nothing warns about this.
-    - **Moving** one in does keep it, and later growth still allocates from that arena -- but it does not survive a
-      copy of the enclosing `basic_json`.
-    - Passing `#!cpp std::pmr::polymorphic_allocator` as `AllocatorType` does not work around any of this; it does
-      not compile.
-
-    Apart from moving a string in, the only way to redirect these allocations is the process-global
-    `#!cpp std::pmr::set_default_resource()`.
-
-!!! tip "Reference implementation"
-
-    `docs/mkdocs/docs/examples/custom_string_type.hpp` wraps a private `#!cpp std::string` and satisfies every
-    requirement above -- a good starting point for a custom `StringType`. The unit test
-    `tests/src/unit-alt-string.cpp` contains a more thorough variant, `alt_string`, exercised against a larger part
-    of the API.
-
-    ```cpp
-    --8<-- "examples/custom_string_type.hpp"
-    ```
-
-??? example "Compiling and using it"
-
-    ```cpp
-    --8<-- "examples/custom_string_type.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/custom_string_type.output"
-    ```
-
-## `BooleanType`
-
-`boolean_t` is stored **directly** inside `basic_json`, as a member of an anonymous union.
-
-### Always required
-
- A literal type that is trivially default-constructible, trivially copyable, and trivially destructible; otherwise the
-  union's special member functions are deleted.
- **Implicitly** convertible from `#!cpp bool` -- an `#!cpp explicit` constructor is not enough, because the
-  `to_json` overload for a custom `BooleanType` is constrained on `#!cpp std::is_convertible` -- and contextually
-  convertible to `#!cpp bool` (here an `#!cpp explicit operator bool` is fine).
- Comparison operators `==`, `!=`, `<`, `<=`, `>`, `>=` (or `<=>`).
- Convertible from and to `#!cpp bool` through the serializer, because
-  [`get<bool>()`](../../api/basic_json/get.md) is used internally.
-
-There is little reason to use anything other than `#!cpp bool` here.
-
-### Compatible types
-
-`#!cpp bool` is the only usable choice. Another trivially copyable type that is implicitly convertible to and from
-`#!cpp bool` -- `#!cpp std::uint8_t`, say -- does compile, and JSON booleans still round-trip, but the type then
-serves as both `boolean_t` and an ordinary integer: `basic_json` can no longer be constructed or assigned from a
-`#!cpp std::uint8_t` at all (the boolean and unsigned-integer `to_json` overloads become ambiguous), and
-[`get<std::uint8_t>()`](../../api/basic_json/get.md) on a number throws
-[`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) instead of returning the value.
-
-## `NumberIntegerType` and `NumberUnsignedType`
-
-Both types are stored **directly** inside `basic_json`'s union.
-
-### Always required
-
- `#!cpp std::is_integral` must be satisfied: `NumberIntegerType` must be a **signed** integer type,
-  `NumberUnsignedType` an **unsigned** integer type. Class types are not supported -- among others, the constructors
-  taking integer values are constrained on `#!cpp std::is_integral`.
- Trivially default-constructible, trivially copyable, and trivially destructible (union member).
- `#!cpp std::numeric_limits` must be specialized for both types.
- `NumberUnsignedType` must be able to represent the absolute value of every `NumberIntegerType` value; serialization
-  of negative numbers converts the value to `NumberUnsignedType`. A `#!cpp static_assert` requires it to be at least as
-  wide as `NumberIntegerType`, which is what that amounts to for the standard integer types.
- Both types must fit into the internal 64-character number buffer used by
-  [`dump`](../../api/basic_json/dump.md), which is the case for all standard integer types.
- [`std::hash<basic_json>`](../../api/basic_json/std_hash.md) additionally requires `#!cpp std::hash` specializations.
-
-### Notes
-
-The number types influence what the parser accepts: an integer literal that does not round-trip through the chosen type
-is stored as [`number_float_t`](../../api/basic_json/number_float_t.md) instead. Choosing types narrower than 64 bits
-therefore silently changes parse results rather than raising an error. See
-[Number Handling](number_handling.md) for details.
-
-### Compatible types
-
-| Type pair                                                                                    | Support                                                                                                                                                                                          |
-|----------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `#!cpp std::int64_t` / `#!cpp std::uint64_t` (default)                                       | full                                                                                                                                                                                             |
-| `#!cpp std::int32_t` / `#!cpp std::uint32_t`, `#!cpp long long` / `#!cpp unsigned long long` | full; narrower types change which literals the parser can represent                                                                                                                              |
-| any other pair of standard signed/unsigned integer types                                     | full                                                                                                                                                                                             |
-| class types, enumerations                                                                    | not usable; `#!cpp std::is_integral` must hold                                                                                                                                                   |
-| `#!cpp bool`, or a type already used for another member of the union                         | not usable; `#!cpp std::is_integral<bool>` is in fact `#!cpp true`, but the `get_impl_ptr` overloads for `boolean_t`, `number_integer_t`, `number_unsigned_t` and `number_float_t` would collide |
-
-## `NumberFloatType`
-
-`number_float_t` is stored **directly** inside `basic_json`'s union.
-
-### Always required
-
- Trivially default-constructible, trivially copyable, and trivially destructible (union member).
- `#!cpp std::numeric_limits` must be specialized; `max_digits10` is used to size the conversion.
- `#!cpp std::isfinite` must be applicable to the type.
-
-### Required for parsing and serialization
-
-`NumberFloatType` must be one of `#!cpp float`, `#!cpp double`, or `#!cpp long double`:
-
- The [parser](../parsing/index.md) converts number literals with `#!cpp std::strtof`, `#!cpp std::strtod`, or
-  `#!cpp std::strtold`; the library provides overloads for exactly these three types.
- [`dump`](../../api/basic_json/dump.md) falls back to `#!cpp std::snprintf` with the `%g` and `%Lg` conversion
-  specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
-  (`#!cpp float` is promoted to `#!cpp double`).
-
-If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or binary64 number, `dump` uses the
-Grisu2 algorithm, which produces the shortest representation that round-trips. Otherwise the `snprintf` fallback with
-`max_digits10` digits is used.
-
-### Required for the binary formats
-
-`NumberFloatType` must be `#!cpp float` or `#!cpp double`. The writers for
-[CBOR, MessagePack, UBJSON, BJData, and BSON](../binary_formats/index.md) map a floating-point value onto an IEEE 754
-binary32 or binary64 field and have no encoding for `#!cpp long double`.
-
-### Compatible types
-
-| Type                     | Support                                                                                                               |
-|--------------------------|-----------------------------------------------------------------------------------------------------------------------|
-| `#!cpp double` (default) | full; short round-trip output through Grisu2                                                                          |
-| `#!cpp float`            | full; short round-trip output through Grisu2                                                                          |
-| `#!cpp long double`      | `dump` and `parse` only; the binary format writers do not compile, as they only handle IEEE 754 binary32 and binary64 |
-| any other type           | not usable                                                                                                            |
-
-## `AllocatorType`
-
-`AllocatorType` is instantiated with **one** argument, for each of `object_t`, `array_t`, `string_t`, `binary_t`,
-`basic_json`, and `#!cpp std::pair<const StringType, basic_json>`.
-
-### Always required
-
- The template must be usable with exactly one type argument. The library instantiates `AllocatorType<T>` directly and
-  never uses `#!cpp std::allocator_traits<...>::rebind_alloc`.
- It must satisfy the [Allocator](https://en.cppreference.com/w/cpp/named_req/Allocator) named requirement so that
-  `#!cpp std::allocator_traits` can be used with it.
- It must be **default-constructible and stateless**. Objects are allocated with a default-constructed allocator and
-  deallocated with a *different* default-constructed allocator, and
-  [`get_allocator()`](../../api/basic_json/get_allocator.md) returns a default-constructed instance. Allocators
-  carrying state are not supported, so there is no way to tell a `basic_json` where to allocate from; see the note
-  under [`StringType`](#stringtype) for what that means in practice. A stateful allocator is **not diagnosed**: it
-  compiles and silently ignores the state.
- It must support **incomplete types**: `AllocatorType<basic_json>` is instantiated inside the definition of
-  `basic_json` itself.
- `#!cpp std::allocator_traits<AllocatorType<basic_json>>::pointer` becomes
-  [`basic_json::pointer`](../../api/basic_json/index.md#container-types), and iterators are constructed from raw
-  `#!cpp basic_json*` values. The `pointer` type must therefore be a plain pointer; fancy pointers are not supported.
-
-### Compatible types
-
-| Type                                                              | Support                                |
-|-------------------------------------------------------------------|----------------------------------------|
-| `#!cpp std::allocator` (default)                                  | full                                   |
-| a custom stateless allocator template                             | full                                   |
-| stateful allocators, e.g. `#!cpp std::pmr::polymorphic_allocator` | not usable; see the requirements above |
-
-## `JSONSerializer`
-
-`JSONSerializer` is instantiated as `JSONSerializer<T, void>` and defaults to
-[`adl_serializer`](../../api/adl_serializer/index.md).
-
-### Always required
-
- The template must accept **two** type arguments. It does not have to give the second one a default -- `basic_json`
-  declares the parameter as `#!cpp template<typename T, typename SFINAE = void> class JSONSerializer`, so uses such as
-  `#!cpp JSONSerializer<T>` inside the library supply `#!cpp void` themselves. The second parameter exists so that
-  partial specializations can be constrained by SFINAE.
- For every type `T` that is converted **to** a JSON value, a static member function
-  `#!cpp static void to_json(basic_json&, T)` must exist.
- For every type `T` that is converted **from** a JSON value, either
-  `#!cpp static void from_json(const basic_json&, T&)` or `#!cpp static T from_json(const basic_json&)` must exist.
-  The latter form is required for types that are not default-constructible; see
-  [Arbitrary Types Conversions](../arbitrary_types.md).
- To support the [converting constructor](../../api/basic_json/basic_json.md) between different `basic_json`
-  specializations, `to_json` must be available for `boolean_t`, `number_integer_t`, `number_unsigned_t`,
-  `number_float_t`, `string_t`, `object_t`, `array_t`, and `binary_t` of the *source* specialization.
-
-### Compatible types
-
-| Type                                                                      | Support                                                           |
-|---------------------------------------------------------------------------|-------------------------------------------------------------------|
-| [`nlohmann::adl_serializer`](../../api/adl_serializer/index.md) (default) | full                                                              |
-| a class template deriving from `adl_serializer`                           | full; the usual way to change behavior while keeping the defaults |
-| an unrelated template with the same interface                             | full, but it has to handle every type the library converts        |
-
-## `BinaryType`
-
-`BinaryType` is not a JSON type; it is used for the byte strings of the
-[binary formats](../binary_formats/index.md). It is wrapped as
-
-```cpp
-using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
-```
-
-### Always required
-
- A non-`final` class type -- [`byte_container_with_subtype`](../../api/byte_container_with_subtype/index.md) derives
-  from it publicly.
- A member type `value_type` that is **exactly one byte** wide (e.g., `#!cpp std::uint8_t`, `#!cpp char`, or
-  `#!cpp std::byte`). Readers and writers reinterpret the container's storage as raw bytes, so a wider `value_type` is
-  rejected with a `#!cpp static_assert`.
- Contiguous storage: the binary readers `#!cpp std::memcpy` into `#!cpp &binary[n]`, the writers `reinterpret_cast`
-  `data()`. `#!cpp data() + n` would do for the readers too, but they share one helper with
-  [`StringType`](#stringtype), whose non-`#!cpp const` `data()` is C++17 and later only.
- Default-constructible, copy-constructible, and move-constructible.
- Member functions `size()`, `empty()`, `data()`, `resize()`, `operator[]`, `back()`, `begin()`, `end()`, `cbegin()`,
-  and `cend()` with random-access iterators, and `insert(pos, first, last)`, which the CBOR reader uses to join the
-  chunks of an indefinite-length byte string. `push_back()` is **not** required.
- Comparison operators: `==` is used by
-  [`byte_container_with_subtype`](../../api/byte_container_with_subtype/index.md), the relational operators by
-  [`basic_json`'s comparison operators](../../api/basic_json/operator_le.md).
-
-### Required for individual functions
-
- `clear()`, for [`basic_json::clear()`](../../api/basic_json/clear.md).
-
-`max_size()`, `at()`, `reserve()`, `erase()`, `pop_back()`, and `emplace_back()` are **not** used at all.
-
-See [`binary_t`](../../api/basic_json/binary_t.md) for how a non-default `BinaryType` changes the meaning of assigning
-such a container to a `basic_json` value.
-
-!!! tip "Reference implementation"
-
-    `docs/mkdocs/docs/examples/custom_binary_type.hpp` wraps a private `#!cpp std::vector<std::uint8_t>` and satisfies
-    every requirement above -- a good starting point for a custom `BinaryType`.
-
-    ```cpp
-    --8<-- "examples/custom_binary_type.hpp"
-    ```
-
-??? example "Compiling and using it"
-
-    ```cpp
-    --8<-- "examples/custom_binary_type.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/custom_binary_type.output"
-    ```
-
-### Compatible containers
-
-| Container                                                                                   | Notes                                                                     |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
-| `#!cpp std::vector<std::uint8_t>` (default)                                                 |                                                                           |
-| `#!cpp std::vector<char>`, `#!cpp std::vector<std::byte>`                                   | `dump()` writes the bytes as 0..255 whichever is used                     |
-| `boost::container::vector<std::uint8_t>`, `boost::container::small_vector<std::uint8_t, N>` |                                                                           |
-| `absl::InlinedVector<std::uint8_t, N>`                                                      | usable here, unlike as an `ArrayType`, because the value type is complete |
-| `eastl::vector<std::uint8_t>`                                                               | usable here, unlike as an `ArrayType`, because `max_size()` is not needed |
-| `folly::fbvector<std::uint8_t>`                                                             | requires C++20, see the note above                                        |
-
-### Containers that cannot be used
-
-| Container                                            | Reason                                                                                                                                                                                             |
-|------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `QByteArray`                                         | no `empty()` (it spells that `isEmpty()`); its `insert` takes an index rather than an iterator; and it converts to `string_t`, which makes `to_json` ambiguous between a string and a binary value |
-| `#!cpp std::string`                                  | `binary_t::container_type` and `string_t` would be the same type, so the two [`swap`](../../api/basic_json/swap.md) overloads collide and `basic_json` cannot be instantiated at all               |
-| `#!cpp std::deque<std::uint8_t>`                     | storage is not contiguous, so there is no `data()`                                                                                                                                                 |
-| containers whose `value_type` is wider than one byte | see above -- accepted by the compiler, wrong at runtime                                                                                                                                            |
-
-## `CustomBaseClass`
-
-`CustomBaseClass` is an extension point: unless it is `#!cpp void` (the default, which selects the empty
-`nlohmann::json_default_base`), `basic_json` publicly derives from it.
-
-### Always required
-
- A non-`final`, default-constructible class type.
- `basic_json` is copy-/move-constructible and copy-/move-assignable only if `CustomBaseClass` is.
-
-### Notes
-
-`basic_json` is documented to be a
-[StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType). Because `basic_json` has
-non-static data members of its own, a `CustomBaseClass` with non-static data members forfeits this guarantee.
-
-Note the namespace of `CustomBaseClass` becomes an associated namespace of `basic_json` for the purpose of
-argument-dependent lookup.
-
-See [`json_base_class_t`](../../api/basic_json/json_base_class_t.md) for an example.
-
-### Compatible types
-
-| Type                                         | Support                                                                    |
-|----------------------------------------------|----------------------------------------------------------------------------|
-| `#!cpp void` (default)                       | an empty base class is used; no effect on `basic_json`                     |
-| any default-constructible, non-`final` class | full; see [`json_base_class_t`](../../api/basic_json/json_base_class_t.md) |
-
-## Cross-specialization conversions
-
-Converting a value from one `basic_json` specialization into another (see the
-[converting constructor](../../api/basic_json/basic_json.md)) imposes two additional requirements that are not
-diagnosed at compile time. With assertions enabled they abort on the `#!cpp JSON_ASSERT` at the end of the converting
-constructor; under `#!cpp NDEBUG` they fail **silently** at runtime:
-
- The target `string_t` must be directly constructible from the source `string_t`. Otherwise the string is converted to
-  an array of character codes.
- The target `object_t::key_type` must be directly constructible from the source object's key type. Otherwise the
-  object is converted to an array of key/value pairs.
-
-See [issue #3425](https://github.com/nlohmann/json/issues/3425), [`string_t`](../../api/basic_json/string_t.md), and
-[`object_t`](../../api/basic_json/object_t.md).
-
-## See also
-
- [Types](index.md) -- overview of how JSON values are stored
- [Number Handling](number_handling.md) -- how the number types affect parsing and serialization
- [Object Order](../object_order.md) -- using an insertion-ordered `ObjectType`
- [`basic_json`](../../api/basic_json/index.md) -- API documentation of the class template
@@ -8,72 +8,41 @@ the result of an internet search. If you know further customers of the library,
 ## Space Exploration

 - [**Peregrine Lunar Lander Flight 01**](https://en.wikipedia.org/wiki/Peregrine_Mission_One) - The library was used for payload management in the **Peregrine Moon Lander**, developed by **Astrobotic Technology** and launched as part of NASA's **Commercial Lunar Payload Services (CLPS)** program. After six days in orbit, the spacecraft was intentionally redirected into Earth's atmosphere, where it burned up over the Pacific Ocean on **January 18, 2024**.
- [**NASA Unsteady Pressure-Sensitive Paint Processing**](https://github.com/nasa/upsp-processing), NASA software for processing high-speed video recordings of wind tunnel tests on launch vehicle and aircraft models
- [**Terma TEMU**](https://temu.terma.com/docs/public/temu-release-notes/latest/copying/json-for-modern-cpp.html), an emulator of spacecraft on-board computers used to develop and validate flight software for European space missions

 ## Automotive

 - [**Alexa Auto SDK**](https://github.com/alexa/alexa-auto-sdk), a software development kit enabling the integration of Alexa into automotive systems
 - [**Apollo**](https://github.com/ApolloAuto/apollo), a framework for building autonomous driving systems
 - [**Automotive Grade Linux (AGL)**](https://download.automotivelinux.org/AGL/release/jellyfish/latest/qemux86-64/deploy/licenses/nlohmann-json/), a collaborative open-source platform for automotive software development
- [**Autoware**](https://github.com/autowarefoundation/autoware_universe), an open-source software stack for autonomous driving built on ROS 2
- [**Eclipse S-CORE**](https://github.com/eclipse-score/nlohmann_json), an open-source software platform for the software-defined vehicle backed by major automotive manufacturers and suppliers
 - [**Genesis Motor** (infotainment)](http://webmanual.genesis.com/ccIC/AVNT/JW/KOR/English/reference010.html), a luxury automotive brand
 - [**Hyundai** (infotainment)](https://www.hyundai.com/wsvc/ww/download.file.do?id=/content/hyundai/ww/data/opensource/data/GN7-2022/licenseCode/info), a global automotive brand
 - [**Kia** (infotainment)](http://webmanual.kia.com/PREM_GEN6/AVNT/RJPE/KOR/Korean/reference010.html), a global automotive brand
 - [**Mercedes-Benz Operating System (MB.OS)**](https://group.mercedes-benz.com/careers/about-us/mercedes-benz-operating-system/), a core component of the vehicle software ecosystem from Mercedes-Benz
- [**NVIDIA DRIVE OS**](https://developer.nvidia.com/docs/drive/drive-os/6.0.5/public/driveworks-nvcgf/dwx_open_source_attribution.html), the operating system and DriveWorks SDK powering NVIDIA's platform for autonomous vehicles
 - [**Rivian** (infotainment)](https://assets.ctfassets.net/2md5qhoeajym/3cwyo4eoufk4yingUwusFt/ded2c47da620fdfc99c88c7156d2c1d8/In-Vehicle_OSS_Attribution_2024__11-24_.pdf), an electric vehicle manufacturer
 - [**Suzuki** (infotainment)](https://www.globalsuzuki.com/motorcycle/ipc/oss/oss_48KA_00.pdf), a global automotive and motorcycle manufacturer

 ## Gaming and Entertainment

- [**Anno 117: Pax Romana**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a city-building strategy game set in the Roman Empire
 - [**Assassin's Creed: Mirage**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a stealth-action game set in the Middle East, focusing on the journey of a young assassin with classic parkour and stealth mechanics
- [**Battlefield 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a military first-person shooter known for its large-scale multiplayer battles
- [**Battlefield: REDSEC**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play battle royale experience set in the Battlefield universe
- [**BioMenace: Remastered**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a remaster of the classic side-scrolling platform shooter
 - [**Chasm: The Rift**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a first-person shooter blending horror and adventure, where players navigate dark realms and battle monsters
 - [**College Football 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring gameplay that mimics real-life college teams and competitions
- [**College Football 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring licensed teams and stadiums
- [**College Football 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the college football simulation series
 - [**Concepts**](https://concepts.app/en/licenses), a digital sketching app designed for creative professionals, offering flexible drawing tools for illustration, design, and brainstorming
 - [**Depthkit**](https://www.depthkit.tv/third-party-licenses), a tool for creating and capturing volumetric video, enabling immersive 3D experiences and interactive content
- [**Dune: Awakening**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world survival MMO set on the desert planet Arrakis
- [**EA Sports FC 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an association football simulation with club, career, and online modes
- [**EA Sports FC 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the association football simulation series
- [**EA Sports UFC 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a mixed martial arts fighting simulation
- [**FiveM**](https://github.com/citizenfx/fivem), a modification framework for Grand Theft Auto V that powers custom multiplayer servers
- [**FLUX:: Immersive**](https://doc.flux.audio/syrah/Credits.html), a suite of professional audio processing and immersive mixing plugins used in music and post-production
 - [**IMG.LY**](https://img.ly/acknowledgements), a platform offering creative tools and SDKs for integrating advanced image and video editing in applications
- [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications
- [**Kodi**](https://github.com/xbmc/xbmc/blob/master/xbmc/utils/JSONVariantWriter.cpp), a home theater and media center application
 - [**LOOT**](https://loot.readthedocs.io/_/downloads/en/0.13.0/pdf/), a tool for optimizing the load order of game plugins, commonly used in The Elder Scrolls and Fallout series
- [**LunaTranslator**](https://github.com/HIllya51/LunaTranslator/blob/main/src/NativeImpl/LunaSubprocess/aspatch.cpp), a real-time translation tool for visual novels
- [**MaaAssistantArknights**](https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/dev-v2/src/MaaCore/Vision/Roguelike/BlackFlow/BlackFlowMapAnalyzer.cpp), an automation assistant for the mobile game Arknights
 - [**Madden NFL 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a sports simulation game capturing the excitement of American football with realistic gameplay and team management features
- [**Madden NFL 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an American football simulation with franchise and team management modes
- [**Madden NFL 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the American football simulation series
 - [**Marne**](https://marne.io/licenses), an unofficial private server platform for hosting custom Battlefield 1 game experiences
 - [**Minecraft**](https://www.minecraft.net/zh-hant/attribution), a popular sandbox video game
- [**Mumble**](https://github.com/mumble-voip/mumble), a low-latency, open-source voice chat application widely used by gaming communities
 - [**NHL 22**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a hockey simulation game offering realistic gameplay, team management, and various modes to enhance the hockey experience
- [**OBS Studio**](https://github.com/obsproject/obs-studio), a free and open-source suite for video recording and live streaming
- [**OpenRCT2**](https://github.com/OpenRCT2/OpenRCT2/blob/develop/src/openrct2/core/JsonFwd.hpp), an open source re-implementation of RollerCoaster Tycoon 2
 - [**Pixelpart**](https://pixelpart.net/documentation/book/third-party.html), a 2D animation and video compositing software that allows users to create animated graphics and visual effects with a focus on simplicity and ease of use
 - [**Razer Cortex**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a gaming performance optimizer and system booster designed to enhance the gaming experience
 - [**Red Dead Redemption II**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world action-adventure game following an outlaw's story in the late 1800s, emphasizing deep storytelling and immersive gameplay
- [**RetroArch**](https://github.com/libretro/RetroArch), a frontend for emulators, game engines, and media players built on the libretro API
- [**shadPS4**](https://github.com/shadps4-emu/shadPS4/blob/main/src/core/user_manager.h), a PlayStation 4 emulator for Windows, Linux and macOS
- [**skate.**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play skateboarding game set in an open world
 - [**Snapchat**](https://www.snap.com/terms/license-android), a multimedia messaging and augmented reality app for communication and entertainment
- [**Steel Century Groove**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an action game released in 2026
- [**Sunshine**](https://github.com/LizardByte/Sunshine/blob/master/src/confighttp.h), a self-hosted game streaming host compatible with Moonlight clients
 - [**Tactics Ogre: Reborn**](https://www.square-enix-games.com/en_US/documents/tactics-ogre-reborn-pc-installer-software-and-associated-plug-ins-disclosure), a tactical role-playing game featuring strategic battles and deep storytelling elements
 - [**Throne and Liberty**](https://www.amazon.com/gp/help/customer/display.html?nodeId=T7fLNw5oAevCMtJFPj&pop-up=1), an MMORPG that offers an expansive fantasy world with dynamic gameplay and immersive storytelling
 - [**Unity Vivox**](https://docs.unity3d.com/Packages/com.unity.services.vivox@15.1/license/Third%20Party%20Notices.html), a communication service that enables voice and text chat functionality in multiplayer games developed with Unity
- [**xemu**](https://github.com/xemu-project/xemu), an emulator of the original Xbox console
 - [**Zool: Redimensioned**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a modern reimagining of the classic platformer featuring fast-paced gameplay and vibrant environments
+- [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications

 ## Consumer Electronics

@@ -81,195 +50,109 @@ the result of an internet search. If you know further customers of the library,
 - [**Canon CanoScan LIDE**](https://carolburo.com/wp-content/uploads/2024/06/LiDE400_OnlineManual_Win_FR_V02.pdf), a series of flatbed scanners offering high-resolution image scanning for home and office use
 - [**Canon PIXMA Printers**](https://www.mediaexpert.pl/products/files/73/7338196/Instrukcja-obslugi-CANON-Pixma-TS7450i.pdf), a line of all-in-one inkjet printers known for high-quality printing and wireless connectivity
 - [**Cisco Webex Desk Camera**](https://www.cisco.com/c/dam/en_us/about/doing_business/open_source/docs/CiscoWebexDeskCamera-23-1622100417.pdf), a video camera designed for professional-quality video conferencing and remote collaboration
- [**DJI Edge SDK**](https://github.com/dji-sdk/Edge-SDK-V2-Demo), the reference applications for DJI's Edge SDK, used to build edge computing services on DJI drone docks
- [**Elgato Stream Deck**](https://github.com/elgatosf/streamdeck-obs-plugin2), a family of programmable control surfaces for content creators and their plugin ecosystem
- [**Instagrid**](https://instagrid.co/intellectual-property/foss), a manufacturer of portable, high-performance battery systems for professional mobile power supply
- [**iRobot**](https://iot-content.irobot.com/iw/sfsites/c/cms/delivery/media/MCKRLTPDJSSJBNJKDA5SG5UVVIIQ), a manufacturer of autonomous home robots including the Roomba vacuum cleaner range
- [**Logitech Logi Bolt**](https://opensource.logitech.com/wiki/Logi_BoltApp/), the management application for Logitech's secure wireless connectivity technology
- [**Novitus**](https://novitus.pl/licencjepensource), a manufacturer of fiscal cash registers and point-of-sale devices
 - [**Philips Hue Personal Wireless Lighting**](http://2ak5ape.257.cz/), a smart lighting system for customizable and wireless home illumination
 - [**Ray-Ban Meta Smart glasses**](https://www.meta.com/de/en/legal/smart-glasses/third-party-notices-android/03/), a pair of smart glasses designed for capturing photos and videos with integrated connectivity and social features
 - [**Razer Synapse**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a unified configuration software enabling hardware customization for Razer devices
- [**Sharp Professional Displays**](https://jp.sharp/restricted/business/lcd-display/cms/images/source_pnla862/PN-LA652_752_862_LicenseInformation.pdf), a range of large-format interactive displays for business and education
 - [**Siemens SINEMA Remote Connect**](https://cache.industry.siemens.com/dl/files/790/109793790/att_1054961/v2/OSS_SINEMA-RC_86.pdf), a remote connectivity solution for monitoring and managing industrial networks and devices securely
- [**Skydio**](https://pages.skydio.com/rs/784-TUF-591/images/Open%20Source%20Software%20Notice%20v0.2.html), a manufacturer of autonomous drones for inspection, public safety, and defense applications
 - [**Sony PlayStation 4**](https://doc.dl.playstation.net/doc/ps4-oss/index.html), a gaming console developed by Sony that offers a wide range of games and multimedia entertainment features
- [**Sony Spatial Reality Display**](https://www.sony.co.jp/en/Products/Developer-Spatial-Reality-display/download/dcc-tools/blender-plugin/SpatiaRealityDisplayPluginforPreviewBL_Manual.pdf), a glasses-free stereoscopic 3D display and its plugins for Blender, 3ds Max, and ZBrush
 - [**Sony Virtual Webcam Driver for Remote Camera**](https://helpguide.sony.net/rc/vwd/v1/zh-cn/print.pdf), a software driver that enables the use of Sony cameras as virtual webcams for video conferencing and streaming
- [**Yamaha Clavinova**](https://usa.yamaha.com/files/download/other_assets/1/2298171/CLP-800_oss_license.pdf), a series of digital pianos combining acoustic piano feel with digital sound technology

-## Operating Systems and Platforms
+## Operating Systems

 - [**Apple iOS and macOS**](https://www.apple.com/macos), a family of operating systems developed by Apple, including iOS for mobile devices and macOS for desktop computers
- [**Chromium**](https://chromium.googlesource.com/chromium/src/+/main/third_party/nlohmann_json/), the open-source browser project that Google Chrome, Microsoft Edge, and many other browsers are built on, where the library is used as data container for on-device model execution
 - [**Google Fuchsia**](https://fuchsia.googlesource.com/third_party/json/), an open-source operating system developed by Google, designed to be secure, updatable, and adaptable across various devices
- [**LG webOS**](https://github.com/webosose/com.webos.service.camera), a Linux-based operating system used in LG smart TVs, signage, and embedded devices
- [**Microsoft Azure Linux**](https://github.com/microsoft/azurelinux), a Linux distribution developed by Microsoft for Azure infrastructure and edge workloads
- [**OpenHarmony**](https://github.com/openharmony/third_party_json), an open-source operating system for smart devices and the foundation of HarmonyOS
 - [**SerenityOS**](https://github.com/SerenityOS/serenity), an open-source operating system that aims to provide a simple and beautiful user experience with a focus on simplicity and elegance
- [**Windows Subsystem for Linux**](https://github.com/microsoft/WSL), a compatibility layer that runs Linux environments natively on Windows
 - [**Yocto**](http://ftp.emacinc.com/openembedded-sw/kirkstone-icop-5.15-kirkstone-6.0/archive-2024-10/pn8m-090t-ppc/licenses/nlohmann-json/), a Linux-based build system for creating custom operating systems and software distributions, tailored for embedded devices and IoT applications

 ## Development Tools and IDEs

 - [**Accentize SpectralBalance**](https://www.accentize.com/products/SpectralBalanceManual.pdf), an adaptive speech analysis tool designed to enhance audio quality by optimizing frequency balance in recordings
- [**Airbus Ghidralligator**](https://www.cyber.airbus.com/en/newsroom/stories/2025-06-ghidralligator), a Ghidra-based emulator from Airbus CyberSecurity used to fuzz and analyse embedded firmware
- [**Apache brpc**](https://github.com/apache/brpc/blob/master/src/butil/iobuf.h), an industrial-grade remote procedure call framework for C++
 - [**Arm Compiler for Linux**](https://documentation-service.arm.com/static/66558e9d876c8d213b7843e4), a software development toolchain for compiling and optimizing applications on Arm-based Linux systems
 - [**BBEdit**](https://s3.amazonaws.com/BBSW-download/BBEdit_15.1.2_User_Manual.pdf), a professional text and code editor for macOS
 - [**CoderPad**](https://coderpad.io), a collaborative coding platform that enables real-time code interviews and assessments for developers; the library is included in every CoderPad instance and can be accessed with a simple `#include "json.hpp"`
- [**Codon**](https://github.com/exaloop/codon/blob/develop/jupyter/jupyter.h), an ahead-of-time compiler for a Python-like language
 - [**Compiler Explorer**](https://godbolt.org), a web-based tool that allows users to write, compile, and visualize the assembly output of code in various programming languages; the library is readily available and accessible with the directive `#include <nlohmann/json.hpp>`.
- [**Flutter**](https://github.com/flutter/flutter/blob/master/engine/src/flutter/impeller/compiler/reflector.cc), a UI toolkit for building natively compiled applications for mobile, web, and desktop from a single codebase
- [**Fraunhofer VVenC**](https://github.com/fraunhoferhhi/vvenc), a fast and efficient encoder for the Versatile Video Coding (H.266/VVC) standard
- [**GitHub CodeQL**](https://github.com/github/codeql/blob/main/shared/cpp/Diagnostics.h), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
- [**GoPro ngfx**](https://github.com/gopro/ngfx), a low-level graphics abstraction and profiling framework developed by GoPro
- [**gRPC**](https://github.com/grpc/grpc/blob/master/tools/artifact_gen/utils.h), a high-performance universal remote procedure call framework
+- [**GitHub CodeQL**](https://github.com/github/codeql), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
 - [**Hex-Rays**](https://docs.hex-rays.com/user-guide/user-interface/licenses), a reverse engineering toolset for analyzing and decompiling binaries, primarily used for security research and vulnerability analysis
 - [**ImHex**](https://github.com/WerWolv/ImHex), a hex editor designed for reverse engineering, providing advanced features for data analysis and manipulation
- [**Intel GITS**](https://github.com/intel/gits), a tool for capturing and replaying graphics API calls for debugging and performance analysis
 - [**Intel GPA Framework**](https://intel.github.io/gpasdk-doc/src/licenses.html), a suite of cross-platform tools for capturing, analyzing, and optimizing graphics applications across different APIs
 - [**Intopix**](https://www.intopix.com/software-licensing), a provider of advanced image processing and compression solutions used in software development and AV workflows
 - [**Java SE**](https://www.oracle.com/a/tech/docs/jdk8-lium.pdf), the core Java platform that provides the libraries and runtime needed to build and run general-purpose Java applications
- [**Meta Yoga**](https://github.com/facebook/yoga), a layout engine that facilitates flexible and efficient user interface design across multiple platforms
 - [**MKVToolNix**](https://mkvtoolnix.download/doc/README.md), a set of tools for creating, editing, and inspecting MKV (Matroska) multimedia container files
- [**MRTech IFF SDK**](https://mr-technologies.com/pub/iff-sdk-manual-2-0-1/iff-sdk-manual-2-0-1.pdf), an image processing SDK for machine vision applications with GPU-accelerated pipelines
- [**Nix**](https://github.com/NixOS/nix/blob/master/src/nix/build.cc), a purely functional package manager
- [**Notepad++**](https://github.com/notepad-plus-plus/notepad-plus-plus), a free source code editor that supports various programming languages
+- [**Meta Yoga**](https://github.com/facebook/yoga), a layout engine that facilitates flexible and efficient user interface design across multiple platforms
 - [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
- [**openFrameworks**](https://github.com/openframeworks/openFrameworks/blob/master/libs/openFrameworks/utils/ofJson.h), a community-developed C++ toolkit for creative coding
+- [**Notepad++**](https://github.com/notepad-plus-plus/notepad-plus-plus), a free source code editor that supports various programming languages
 - [**OpenRGB**](https://gitlab.com/CalcProgrammer1/OpenRGB), an open source RGB lighting control that doesn't depend on manufacturer software
 - [**OpenTelemetry C++**](https://github.com/open-telemetry/opentelemetry-cpp), a library for collecting and exporting observability data in C++, enabling developers to implement distributed tracing and metrics in their application
- [**Oracle GraalVM**](https://docs.oracle.com/en/graalvm/jdk/21/docs/licensing-information/), a high-performance JDK distribution with ahead-of-time compilation and polyglot runtime support
- [**Philips amp-cucumber-cpp-runner**](https://github.com/philips-software/amp-cucumber-cpp-runner), a behaviour-driven development test runner for embedded C++ software developed at Philips
 - [**Qt Creator**](https://doc.qt.io/qtcreator/qtcreator-attribution-json-nlohmann.html), an IDE for developing applications using the Qt application framework
- [**Qt for MCUs**](https://doc.qt.io/QtForMCUs/quickultralite-attribution-nlohmann-json.html), a graphics framework for building fluid user interfaces on microcontrollers
- [**React Native**](https://github.com/react/react-native/blob/main/packages/react-native/ReactCxxPlatform/react/devsupport/PackagerConnection.cpp), a framework for building native mobile applications using React
 - [**Scanbot SDK**](https://docs.scanbot.io/barcode-scanner-sdk/web/third-party-libraries/), a software development kit (SDK) that provides tools for integrating advanced document scanning and barcode scanning capabilities into applications
- [**STMicroelectronics TouchGFX**](https://www.st.com/resource/en/additional_license_terms/additional-license-terms-x-cube-touchgfx.html), a graphical user interface framework shipped with STM32 microcontrollers for building embedded HMIs
- [**swagger-codegen**](https://github.com/swagger-api/swagger-codegen/blob/master/samples/server/petstore/pistache-server/model/Pet.h), a template-driven engine that generates API clients and server stubs from an OpenAPI specification
- [**Swoole**](https://github.com/swoole/swoole-src/blob/master/ext-src/swoole_admin_server.cc), a coroutine-based concurrency engine for PHP
- [**Tracy Profiler**](https://github.com/wolfpld/tracy/blob/master/profiler/src/profiler/TracyLlm.hpp), a real-time frame profiler for games and other applications
- [**WasmEdge**](https://github.com/WasmEdge/WasmEdge/blob/master/plugins/wasi_nn/GGML/tts/tts_core.cpp), a lightweight WebAssembly runtime for edge and cloud workloads
- [**x64dbg**](https://github.com/x64dbg/x64dbg/blob/development/src/cross/remote_table/TableRpcData.h), an open source user mode debugger for Windows, aimed at reverse engineering and malware analysis

 ## Machine Learning and AI

- [**Alibaba MNN**](https://github.com/alibaba/MNN), a lightweight deep learning inference engine for mobile and embedded devices
- [**AMD Gaia**](https://github.com/amd/gaia), an open-source framework for running generative AI applications locally on AMD hardware
- [**AMD Vitis AI (VAIP)**](https://github.com/amd/vaip), the execution provider stack that runs AI models on AMD Ryzen AI and adaptive computing devices
 - [**Apple Core ML Tools**](https://github.com/apple/coremltools), a set of tools for converting and configuring machine learning models for deployment in Apple's Core ML framework
 - [**Avular Mobile Robotics**](https://www.avular.com/licenses/nlohmann-json-3.9.1.txt), a platform for developing and deploying mobile robotics solutions
- [**FunASR**](https://github.com/modelscope/FunASR/blob/main/runtime/http/bin/asr_sessions.h), a speech recognition toolkit for training and deploying end-to-end models
 - [**Google gemma.cpp**](https://github.com/google/gemma.cpp), a lightweight C++ inference engine designed for running AI models from the Gemma family
- [**Google Magenta The Infinite Crate**](https://github.com/magenta/the-infinite-crate), an open-source generative AI plugin for digital audio workstations from Google's Magenta research team
- [**GPT4All**](https://github.com/nomic-ai/gpt4all/blob/main/gpt4all-chat/src/tool.h), a desktop application for running local large language models on consumer hardware
- [**Huawei MindSpore**](https://github.com/mindspore-ai/mindspore/blob/master/Third_Party_Open_Source_Software_Notice), a deep learning framework for training and inference across device, edge, and cloud
- [**KTransformers**](https://github.com/kvcache-ai/ktransformers/blob/main/archive/csrc/balance_serve/sched/model_config.h), a framework for heterogeneous large language model inference
 - [**llama.cpp**](https://github.com/ggerganov/llama.cpp), a C++ library designed for efficient inference of large language models (LLMs), enabling streamlined integration into applications
- [**LocalAI**](https://github.com/mudler/LocalAI/blob/master/backend/cpp/ds4/dsml_renderer.cpp), a self-hosted inference engine that exposes local models through an OpenAI-compatible API
 - [**MLX**](https://github.com/ml-explore/mlx), an array framework for machine learning on Apple Silicon
 - [**Mozilla llamafile**](https://github.com/Mozilla-Ocho/llamafile), a tool designed for distributing and executing large language models (LLMs) efficiently using a single file format
 - [**NVIDIA ACE**](https://docs.nvidia.com/ace/latest/index.html), a suite of real-time AI solutions designed for the development of interactive avatars and digital human applications, enabling scalable and sophisticated user interactions
- [**NVIDIA Instant NGP**](https://github.com/NVlabs/instant-ngp/blob/master/src/nerf_loader.cu), an implementation of instant neural graphics primitives for rapid scene reconstruction
- [**NVIDIA TensorRT**](https://github.com/NVIDIA/TensorRT), an SDK for high-performance deep learning inference, including its TensorRT-LLM extension for large language models
- [**NVIDIA TensorRT-LLM**](https://github.com/NVIDIA/TensorRT-LLM/blob/main/cpp/tensorrt_llm/common/safetensors.cpp), a toolkit for optimizing and serving large language model inference on GPUs
- [**ONNX Runtime**](https://github.com/microsoft/onnxruntime), a cross-platform inference and training accelerator for machine learning models
- [**OpenVINO**](https://github.com/openvinotoolkit/openvino), Intel's toolkit for optimizing and deploying deep learning inference across CPUs, GPUs, and NPUs
- [**PaddleOCR**](https://github.com/PaddlePaddle/PaddleOCR/blob/main/deploy/cpp_infer/src/modules/text_detection/result.cc), an optical character recognition toolkit that turns documents and images into structured data
- [**PaddlePaddle**](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/ap/src/axpr/anf_expr.cc), a deep learning framework for distributed training and inference
 - [**Peer**](https://support.peer.inc/hc/en-us/articles/17261335054235-Licenses), a platform offering personalized AI assistants for interactive learning and creative collaboration
- [**PyTorch**](https://github.com/pytorch/pytorch), a machine learning framework for building and training neural networks, widely used in research and production
- [**Qualcomm AI Engine Direct**](https://github.com/qualcomm/qai-appbuilder), a toolchain for building and running generative AI applications on Snapdragon devices
- [**sherpa-onnx**](https://github.com/k2-fsa/sherpa-onnx/blob/master/sherpa-onnx/csrc/sentence-piece-tokenizer.cc), a speech toolkit for on-device recognition, synthesis and speaker diarization
 - [**stable-diffusion.cpp**](https://github.com/leejet/stable-diffusion.cpp), a C++ implementation of the Stable Diffusion image generation model
 - [**TanvasTouch**](https://tanvas.co/tanvastouch-sdk-third-party-acknowledgments), a software development kit (SDK) that enables developers to create tactile experiences on touchscreens, allowing users to feel textures and physical sensations in a digital environment
 - [**TensorFlow**](https://github.com/tensorflow/tensorflow), a machine learning framework that facilitates the development and training of models, supporting data serialization and efficient data exchange between components
- [**whisper.cpp**](https://github.com/ggml-org/whisper.cpp), a C++ implementation of OpenAI's Whisper automatic speech recognition model

 ## Scientific Research and Analysis

 - [**BLACK**](https://www.black-sat.org/en/stable/installation/linux.html), a bounded linear temporal logic (LTL) satisfiability checker
- [**CERN ALICE O2**](https://github.com/AliceO2Group/AliceO2), the online-offline computing framework of the ALICE heavy-ion experiment at the Large Hadron Collider
 - [**CERN Atlas Athena**](https://gitlab.cern.ch/atlas/athena/-/blob/main/Control/PerformanceMonitoring/PerfMonComps/src/PerfMonMTSvc.h), a software framework used in the ATLAS experiment at the Large Hadron Collider (LHC) for performance monitoring
- [**CERN CMSSW**](https://github.com/cms-sw/cmssw), the offline software framework of the CMS experiment at the Large Hadron Collider
- [**CERN Gaudi**](https://gitlab.cern.ch/gaudi/Gaudi), the event-processing framework used by the LHCb and ATLAS experiments at the Large Hadron Collider
 - [**ICU**](https://github.com/unicode-org/icu), the International Components for Unicode, a mature library for software globalization and multilingual support
 - [**KAMERA**](https://github.com/Kitware/kamera), a platform for synchronized data collection and real-time deep learning to map marine species like polar bears and seals, aiding Arctic ecosystem research
 - [**KiCad**](https://gitlab.com/kicad/code/kicad/-/tree/master/thirdparty/nlohmann_json), a free and open-source software suite for electronic design automation
- [**LLNL ROSE**](https://github.com/llnl/rose), a compiler infrastructure from Lawrence Livermore National Laboratory for building source-to-source program analysis and transformation tools
 - [**Maple**](https://www.maplesoft.com/support/help/Maple/view.aspx?path=copyright), a symbolic and numeric computing environment for advanced mathematical modeling and analysis
 - [**MeVisLab**](https://mevislabdownloads.mevis.de/docs/current/MeVis/ThirdParty/Documentation/Publish/ThirdPartyReference/index.html), a software framework for medical image processing and visualization.
- [**MITK**](https://github.com/MITK/MITK), the Medical Imaging Interaction Toolkit, a framework for developing interactive medical image processing software
 - [**OpenPMD API**](https://openpmd-api.readthedocs.io/en/0.8.0-alpha/backends/json.html), a versatile programming interface for accessing and managing scientific data, designed to facilitate the efficient storage, retrieval, and sharing of simulation data across various applications and platforms
- [**ORNL DataFed**](https://github.com/ORNL/DataFed), a federated scientific data management system developed at Oak Ridge National Laboratory
 - [**ParaView**](https://github.com/Kitware/ParaView), an open-source tool for large-scale data visualization and analysis across various scientific domains
 - [**QGIS**](https://gitlab.b-data.ch/qgis/qgis/-/blob/backport-57658-to-release-3_34/external/nlohmann/json.hpp), a free and open-source geographic information system (GIS) application that allows users to create, edit, visualize, and analyze geospatial data across a variety of formats
- [**Sandia InterSpec**](https://github.com/sandialabs/InterSpec), spectral radiation analysis software from Sandia National Laboratories for identifying radioactive isotopes
- [**VolView**](https://github.com/Kitware/VolView), a lightweight application for interactive visualization and analysis of 3D medical imaging data.
 - [**VTK**](https://github.com/Kitware/VTK), a software library for 3D computer graphics, image processing, and visualization
+- [**VolView**](https://github.com/Kitware/VolView), a lightweight application for interactive visualization and analysis of 3D medical imaging data.

 ## Business and Productivity Software

 - [**ArcGIS PRO**](https://www.esri.com/content/dam/esrisites/en-us/media/legal/open-source-acknowledgements/arcgis-pro-2-8-attribution-report.html), a desktop geographic information system (GIS) application developed by Esri for mapping and spatial analysis
 - [**Autodesk Desktop**](https://damassets.autodesk.net/content/dam/autodesk/www/Company/legal-notices-trademarks/autodesk-desktop-platform-components/internal-autodesk-components-web-page-2023.pdf), a software platform developed by Autodesk for creating and managing desktop applications and services
 - [**Check Point**](https://www.checkpoint.com/about-us/copyright-and-trademarks/), a cybersecurity company specializing in threat prevention and network security solutions, offering a range of products designed to protect enterprises from cyber threats and ensure data integrity
- [**EasyEffects**](https://github.com/wwmm/easyeffects/blob/master/src/presets_manager.hpp), an audio effects processor for PipeWire offering limiting, compression and equalization
- [**espanso**](https://github.com/espanso/espanso/blob/dev/espanso-ui/src/win32/native.cpp), a cross-platform text expander
- [**Karabiner-Elements**](https://github.com/pqrs-org/Karabiner-Elements/blob/main/src/share/app_icon.hpp), a keyboard customizer for macOS
- [**MacType**](https://github.com/snowie2000/mactype/blob/directwrite/settings.h), a font rendering engine for Windows
- [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
 - [**Microsoft Office for Mac**](https://officecdnmac.microsoft.com/pr/legal/mac/OfficeforMacAttributions.html), a suite of productivity applications developed by Microsoft for macOS, including tools for word processing, spreadsheets, and presentations
 - [**Microsoft Teams**](https://www.microsoft.com/microsoft-teams/), a team collaboration application offering workspace chat and video conferencing, file storage, and integration of proprietary and third-party applications and services
- [**MuseScore**](https://github.com/musescore/MuseScore), a free and open-source music notation and composition application
- [**NanaZip**](https://github.com/M2Team/NanaZip/blob/main/NanaZip.Codecs/NanaZip.Codecs.Archive.ElectronAsar.cpp), a 7-Zip derivative built for modern Windows
 - [**Nexthink Infinity**](https://docs.nexthink.com/legal/services-terms/experience-open-source-software-licenses/infinity-2022.8-software-licenses), a digital employee experience management platform for monitoring and improving IT performance
 - [**Sophos Connect Client**](https://docs.sophos.com/nsg/licenses/SophosConnect/SophosConnectAttribution.html), a secure VPN client from Sophos that allows remote users to connect to their corporate network, ensuring secure access to resources and data
 - [**Stonebranch**](https://stonebranchdocs.atlassian.net/wiki/spaces/UA77/pages/799545647/Licenses+for+Third-Party+Libraries), a cloud-based cybersecurity solution that integrates backup, disaster recovery, and cybersecurity features to protect data and ensure business continuity for organizations
 - [**Tablecruncher**](https://tablecruncher.com/), a data analysis tool that allows users to import, analyze, and visualize spreadsheet data, offering interactive features for better insights and decision-making
- [**VNote**](https://github.com/vnotex/vnote/blob/master/src/core/services/notebookcoreservice.cpp), a Markdown-based note-taking application written in C++
+- [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality

 ## Databases and Big Data

 - [**ADIOS2**](https://code.ornl.gov/ecpcitest/adios2/-/tree/pr4285_FFSUpstream/thirdparty/nlohmann_json?ref_type=heads), a data management framework designed for high-performance input and output operations
- [**Apache Doris**](https://github.com/apache/doris/blob/master/be/src/runtime/be_proc_monitor.cpp), a real-time analytical database for high-concurrency queries
- [**Claris FileMaker Server**](https://www.claris.com/company/legal/docs/acknowledgements/filemaker-server-macwin/claris_fms2025_acknowledgements_en.pdf), the server platform hosting FileMaker custom apps and databases, developed by Apple subsidiary Claris
- [**ClickHouse**](https://github.com/ClickHouse/ClickHouse), a column-oriented database management system for real-time analytical queries
 - [**Cribl Stream**](https://docs.cribl.io/stream/third-party-current-list/), a real-time data processing platform that enables organizations to collect, route, and transform observability data, enhancing visibility and insights into their systems
 - [**DB Browser for SQLite**](https://github.com/sqlitebrowser/sqlitebrowser), a visual open-source tool for creating, designing, and editing SQLite database files
- [**Manticore Search**](https://github.com/manticoresoftware/manticoresearch/blob/main/src/searchdhttpcompat.cpp), a database for search, offering full-text and vector queries
- [**Milvus**](https://github.com/milvus-io/milvus/blob/master/internal/core/src/query/PlanImpl.h), a cloud-native vector database built for embedding similarity search
- [**MongoDB**](https://github.com/mongodb/mongo/blob/master/src/mongo/replay/config_handler.cpp), a general-purpose document database
 - [**MySQL Connector/C++**](https://docs.oracle.com/cd/E17952_01/connector-cpp-9.1-license-com-en/license-opentelemetry-cpp-com.html), a C++ library for connecting and interacting with MySQL databases
 - [**MySQL NDB Cluster**](https://downloads.mysql.com/docs/licenses/cluster-9.0-com-en.pdf), a distributed database system that provides high availability and scalability for MySQL databases
 - [**MySQL Shell**](https://downloads.mysql.com/docs/licenses/mysql-shell-8.0-gpl-en.pdf), an advanced client and code editor for interacting with MySQL servers, supporting SQL, Python, and JavaScript
- [**PrestoDB**](https://github.com/prestodb/presto/blob/master/presto-native-execution/presto_cpp/main/Announcer.cpp), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
+- [**PrestoDB**](https://github.com/prestodb/presto), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
 - [**ROOT Data Analysis Framework**](https://root.cern/doc/v614/classnlohmann_1_1basic__json.html), an open-source data analysis framework widely used in high-energy physics and other fields for data processing and visualization
- [**Typesense**](https://github.com/typesense/typesense/blob/v31/include/join.h), an open source typo-tolerant search engine
- [**Vearch**](https://github.com/jd-opensource/vearch), a distributed vector database developed at JD.com for similarity search and retrieval-augmented generation
 - [**WiredTiger**](https://github.com/wiredtiger/wiredtiger), a high-performance storage engine for databases, offering support for compression, concurrency, and checkpointing

 ## Simulation and Modeling

- [**Adobe Lagrange**](https://github.com/adobe/lagrange), a geometry processing library developed by Adobe for mesh manipulation and analysis
 - [**Arcturus HoloSuite**](https://www.datocms-assets.com/104353/1698904597-holosuite-third-party-software-credits-and-attributions-2.pdf), a software toolset for capturing, editing, and streaming volumetric video, featuring advanced compression technologies for high-quality 3D content creation
 - [**azul**](https://pure.tudelft.nl/ws/files/85338589/tgis.12673.pdf), a fast and efficient 3D city model viewer designed for visualizing urban environments and spatial data
- [**Bambu Studio**](https://github.com/bambulab/BambuStudio), a slicing and print management application for Bambu Lab 3D printers
 - [**Blender**](https://projects.blender.org/blender/blender/search?q=nlohmann), a free and open-source 3D creation suite for modeling, animation, rendering, and more
 - [**cpplot**](https://cpplot.readthedocs.io/en/latest/library_api/function_eigen_8h_1ac080eac0541014c5892a55e41bf785e6.html), a library for creating interactive graphs and charts in C++, which can be viewed in web browsers
 - [**Foundry Nuke**](https://learn.foundry.com/nuke/content/misc/studio_third_party_libraries.html), a powerful node-based digital compositing and visual effects application used in film and television post-production
- [**FreeCAD**](https://github.com/FreeCAD/FreeCAD), a free and open-source parametric 3D CAD modeler for product design and engineering
 - [**GAMS**](https://www.gams.com/47/docs/THIRDPARTY.html), a high-performance mathematical modeling system for optimization and decision support
- [**Keysight WirelessPro**](https://docs.keysight.com/display/engdocwirelesspro/WirelessPro+2026+Release+Notes), a simulation platform for 5G, 5G-Advanced, and 6G cellular network research
 - [**Kitware SMTK**](https://github.com/Kitware/SMTK), a software toolkit for managing simulation models and workflows in scientific and engineering applications
 - [**M-Star**](https://docs.mstarcfd.com/3_Licensing/thirdparty-licenses.html), a computational fluid dynamics software for simulating and analyzing fluid flow
 - [**MapleSim CAD Toolbox**](https://www.maplesoft.com/support/help/MapleSim/view.aspx?path=CADToolbox/copyright), a software extension for MapleSim that integrates CAD models, allowing users to import, manipulate, and analyze 3D CAD data within the MapleSim environment for enhanced modeling and simulation
- [**Microsoft AirSim**](https://github.com/microsoft/AirSim/blob/main/AirLib/include/common/Settings.hpp), a simulator for autonomous vehicles and drones built on Unreal Engine
 - [**NVIDIA Omniverse**](https://docs.omniverse.nvidia.com/composer/latest/common/product-licenses/usd-explorer/usd-explorer-2023.2.0-licenses-manifest.html), a platform for 3D content creation and collaboration that enables real-time simulations and interactive experiences across various industries
- [**OpenSCAD**](https://github.com/openscad/openscad/blob/master/src/core/AIClient.cc), a script-driven solid 3D CAD modeller
- [**OrcaSlicer**](https://github.com/SoftFever/OrcaSlicer), an open-source slicer supporting a wide range of consumer 3D printers
 - [**Pixar Renderman**](https://rmanwiki-26.pixar.com/space/REN26/19662083/Legal+Notice), a photorealistic 3D rendering software developed by Pixar, widely used in the film industry for creating high-quality visual effects and animations
- [**PrusaSlicer**](https://github.com/prusa3d/PrusaSlicer), the slicing software developed by Prusa Research for its 3D printers
 - [**ROS - Robot Operating System**](http://docs.ros.org/en/noetic/api/behaviortree_cpp/html/json_8hpp_source.html), a set of software libraries and tools that assist in developing robot applications
 - [**UBS**](https://www.ubs.com/), a multinational financial services and banking company

@@ -278,31 +161,18 @@ the result of an internet search. If you know further customers of the library,
 - [**Acronis Cyber Protect Cloud**](https://care.acronis.com/s/article/59533-Third-party-software-used-in-Acronis-Cyber-Protect-Cloud?language=en_US), an all-in-one data protection solution that combines backup, disaster recovery, and cybersecurity to safeguard business data from threats like ransomware
 - [**Baereos**](https://gitlab.tiger-computing.co.uk/packages/bareos/-/blob/tiger/bullseye/third-party/CLI11/examples/json.cpp), a backup solution that provides data protection and recovery options for various environments, including physical and virtual systems
 - [**Bitdefender Home Scanner**](https://www.bitdefender.de/site/Main/view/home-scanner-open-source.html), a tool from Bitdefender that scans devices for malware and security threats, providing a safeguard against potential online dangers
- [**Cisco MLS++**](https://github.com/cisco/mlspp), an implementation of the Messaging Layer Security protocol for end-to-end encrypted group messaging
 - [**Citrix Provisioning**](https://docs.citrix.com/en-us/provisioning/2203-ltsr/downloads/pvs-third-party-notices-2203.pdf), a solution that streamlines the delivery of virtual desktops and applications by allowing administrators to manage and provision resources efficiently across multiple environments
 - [**Citrix Virtual Apps and Desktops**](https://docs.citrix.com/en-us/citrix-virtual-apps-desktops/2305/downloads/third-party-notices-apps-and-desktops.pdf), a solution from Citrix that delivers virtual apps and desktops
 - [**Cyberarc**](https://docs.cyberark.com/Downloads/Legal/Privileged%20Session%20Manager%20for%20SSH%20Third-Party%20Notices.pdf), a security solution that specializes in privileged access management, enabling organizations to control and monitor access to critical systems and data, thereby enhancing overall cybersecurity posture
- [**Deutsche Telekom sysrepo-plugins**](https://github.com/telekom/sysrepo-plugins), a collection of YANG datastore plugins used to manage network devices
 - [**Egnyte Desktop**](https://helpdesk.egnyte.com/hc/en-us/articles/360007071732-Third-Party-Software-Acknowledgements), a secure cloud storage solution designed for businesses, enabling file sharing, collaboration, and data management across teams while ensuring compliance and data protection
 - [**Elster**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a digital platform developed by German tax authorities for secure and efficient electronic tax filing and management using secunet protect4use
- [**Envoy**](https://github.com/envoyproxy/envoy), a cloud-native edge and service proxy that forms the data plane of many service meshes
 - [**Ethereum Solidity**](https://github.com/ethereum/solidity), a high-level, object-oriented programming language designed for implementing smart contracts on the Ethereum platform
- [**gVisor**](https://github.com/google/gvisor), an application kernel that provides a secure sandbox for running untrusted containers
- [**IBM Storage Virtualize**](https://public.dhe.ibm.com/systems/support/warranty/pdfs/stgoilc/SV_for_FS_7300_v8_7_0_Base_OILC.pdf), the software powering IBM FlashSystem enterprise storage arrays
 - [**Inciga**](https://fossies.org/linux/icinga2/third-party/nlohmann_json/json.hpp), a monitoring tool for IT infrastructure, designed to provide insights into system performance and availability through customizable dashboards and alerts
 - [**Intel Accelerator Management Daemon for VMware ESXi**](https://downloadmirror.intel.com/772507/THIRD-PARTY.txt), a management tool designed for monitoring and controlling Intel hardware accelerators within VMware ESXi environments, optimizing performance and resource allocation
 - [**Juniper Identity Management Service**](https://www.juniper.net/documentation/us/en/software/jims/jims-guide/jims-guide.pdf)
- [**Meta FBOSS**](https://github.com/facebook/fboss), the software stack that controls the network switches in Meta's data centers
 - [**Microsoft Azure IoT SDK**](https://library.e.abb.com/public/2779c5f85f30484192eb3cb3f666a201/IP%20Gateway%20Open%20License%20Declaration_9AKK108467A4095_Rev_C.pdf), a collection of tools and libraries to help developers connect, build, and deploy Internet of Things (IoT) solutions on the Azure cloud platform
- [**Microsoft Confidential Consortium Framework**](https://github.com/microsoft/CCF), a framework for building secure, highly available applications on trusted execution environments
 - [**Microsoft WinGet**](https://github.com/microsoft/winget-cli), a command-line utility included in the Windows Package Manager
- [**Mitsubishi Electric SECS/GEM**](https://dl.mitsubishielectric.com/dl/fa/document/manual/plc/sh082483eng/sh082483engi.pdf), the semiconductor equipment communication software running on Mitsubishi Electric C Controller and C intelligent function modules
- [**Moxa**](https://www.moxa.com/getmedia/fbe2a0c7-8dda-4b5b-a501-15e45adebb1f/moxa-foss-statement-for-da-720-series-win-10-ltsc-21h2-declaration-v1.0.pdf), a provider of industrial networking, computing, and automation infrastructure
 - [**plexusAV**](https://www.sisme.com/media/10994/manual_plexusav-p-avn-4-form8244-c.pdf), a high-performance AV-over-IP transceiver device capable of video encoding and decoding using the IPMX standard
 - [**Pointr**](https://docs-dev.pointr.tech/docs/8.x/Developer%20Portal/Open%20Source%20Licenses/), a platform for indoor positioning and navigation solutions, offering tools and SDKs for developers to create location-based applications
 - [**secunet protect4use**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a secure, passwordless multifactor authentication solution that transforms smartphones into digital keyrings, ensuring high security for online services and digital identities
 - [**Sencore MRD 7000**](https://www.foccusdigital.com/wp-content/uploads/2025/03/MRD-7000-Manual-8175V.pdf), a professional multi-channel receiver and decoder supporting UHD and HD stream decoding
- [**Siemens SINEC**](https://cache.industry.siemens.com/dl/files/917/109974917/att_1298783/v2/OSS_SINEC-NMS_99.pdf), a family of network management and infrastructure services for industrial networks
- [**Toshiba Industrial Servers**](https://www.global.toshiba/content/dam/toshiba/jp/products-solutions/industrial/computer/product/server/fs20000r/pdf/FS20000R_OSS_License_6E8C5817_rev0.pdf), the FS20000R series of industrial servers for factory automation and control systems
- [**Wazuh**](https://github.com/wazuh/wazuh/blob/main/src/data_provider/src/sysInfo.cpp), a security platform for threat detection, integrity monitoring and incident response
- [**ZeroTier**](https://github.com/zerotier/ZeroTierOne/blob/dev/osdep/OSUtils.hpp), a software-defined networking service that creates virtual Ethernet networks
@@ -340,8 +340,7 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
 ### json.exception.parse_error.113

 A string could not be read from a [binary format](../features/binary_formats/index.md): either a value that is not a
-string was read where one was required (for instance as a map key), the string's length specification is invalid, or
-the string's bytes are not valid UTF-8.
+string was read where one was required (for instance as a map key), or the string's length specification is invalid.

 !!! failure "Example messages"

@@ -357,9 +356,6 @@ the string's bytes are not valid UTF-8.
    ```
    [json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData string: string length must not be negative
    ```
-    ```
-    [json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: invalid string: ill-formed UTF-8 byte
-    ```

 ### json.exception.parse_error.114

@@ -872,12 +868,6 @@ The size of an array or object in a [binary format](../features/binary_formats/i
 the size following `#` for [UBJSON](../features/binary_formats/ubjson.md)/[BJData](../features/binary_formats/bjdata.md),
 or the encoded length for [CBOR](../features/binary_formats/cbor.md).

-The exception is also thrown for a [UBJSON](../features/binary_formats/ubjson.md) array of a type that is encoded by its
-marker alone (`Z`, `T` or `F`) whose declared count exceeds 1,048,576 (`1 << 20`). Such an array has no payload, so its
-count alone decides how much memory is allocated, and a handful of bytes would otherwise describe billions of values.
-[`to_ubjson`](../api/basic_json/to_ubjson.md) writes longer arrays of these types without the size and type annotation,
-so any value it produces can still be read back.
-
 !!! failure "Example messages"

    ```
@@ -889,9 +879,6 @@ so any value it produces can still be read back.
    ```
    [json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size
    ```
-    ```
-    [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size
-    ```

 ### json.exception.out_of_range.409

@@ -946,34 +933,6 @@ BSON stores the length of documents, arrays, strings, and binary values in a sig
    [`to_bson`](../api/basic_json/to_bson.md) produced documents with negative length prefixes that
    [`from_bson`](../api/basic_json/from_bson.md) rejected.

-### json.exception.out_of_range.413
-
-A JSON Patch `remove` operation cannot be applied because the target location's parent is neither an object nor an array. Per [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902), a `remove` target must reference a member of an existing object or an element of an existing array; a primitive value (string, number, boolean, etc.) or `null` has no members or elements to remove.
-
-!!! failure "Example message"
-
-    ```
-    cannot remove value: the JSON Patch 'remove' target's parent is of type number, but must be an object or array
-    ```
-
-!!! note
-
-    This exception was added in version 3.13.0. Before that, this situation was silently ignored (the `remove` operation had no effect).
-
-### json.exception.out_of_range.414
-
-A JSON Patch `move` operation's `"from"` location is a proper prefix of its `"path"` location. Per [RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902) (section 4.4), a location cannot be moved into one of its own children.
-
-!!! failure "Example message"
-
-    ```
-    cannot move value: 'from' path '/0' is a proper prefix of 'path' '/0/0'
-    ```
-
-!!! note
-
-    This exception was added in version 3.13.0. Before that, this situation could succeed with a corrupted result: for an array target, removing the "from" element before the "add" step shifted subsequent indices, so "path" silently re-resolved to a different element than intended.
-
 ## Further exceptions

 This exception is thrown in case of errors that cannot be classified with the
@@ -98,7 +98,6 @@ nav:
      - Types:
          - features/types/index.md
          - features/types/number_handling.md
-          - features/types/template_parameters.md
  - Integration:
      - integration/index.md
      - integration/migration_guide.md
@@ -297,7 +296,6 @@ nav:
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
-          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
          - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
          - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
          - 'NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_non_intrusive.md
@@ -395,14 +393,7 @@ plugins:
        - http://nlohmann.github.io/json/*
        - https://nlohmann.github.io/json/*
        - mailto:*
-  - privacy:
-      # repology.org refuses requests from GitHub Actions runners, which made
-      # the privacy plugin abort the whole build when it could not download the
-      # package badges (the fetch fails, then reading the missing cache entry
-      # raises FileNotFoundError). Readers' browsers are served normally, so
-      # leave these badges as external references instead of self-hosting them.
-      assets_exclude:
-        - repology.org/*
+  - privacy
  - llmstxt:
      markdown_description: >
        JSON for Modern C++ is a C++11 header-only library implementing a JSON
@@ -1,7 +1,7 @@
 wheel==0.48.0

 mkdocs==1.6.1                                       # documentation framework
-mkdocs-git-revision-date-localized-plugin==1.5.4    # plugin "git-revision-date-localized"
+mkdocs-git-revision-date-localized-plugin==1.5.3    # plugin "git-revision-date-localized"
 mkdocs-material==9.7.7                             # theme for mkdocs
 mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
@@ -398,17 +398,6 @@ inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
    }
 }

-template<typename ConstructibleObjectType>
-auto from_json_object_reserve(ConstructibleObjectType& obj, typename ConstructibleObjectType::size_type size, priority_tag<1> /*unused*/)
-> decltype(obj.reserve(size), void())
-{
-    obj.reserve(size);
-}
-
-template<typename ConstructibleObjectType>
-inline void from_json_object_reserve(ConstructibleObjectType& /*obj*/, std::size_t /*size*/, priority_tag<0> /*unused*/)
-{}
-
 template<typename BasicJsonType, typename ConstructibleObjectType,
         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
@@ -420,7 +409,6 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)

    ConstructibleObjectType ret;
    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-    from_json_object_reserve(ret, inner_object->size(), priority_tag<1> {});
    for (const auto& p : *inner_object)
    {
        ret.emplace(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
@@ -1075,8 +1075,8 @@ char* to_chars(char* first, const char* last, FloatType value)
    }

 #ifdef __GNUC__
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
    if (value == 0) // +-0
    {
@@ -1087,7 +1087,7 @@ char* to_chars(char* first, const char* last, FloatType value)
        return first;
    }
 #ifdef __GNUC__
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#pragma GCC diagnostic pop
 #endif

    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
@@ -33,8 +33,8 @@
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
 #if defined(__clang__)
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -101,10 +101,7 @@ class exception : public std::exception
                    {
                        if (&element.second == current)
                        {
-                            // data() is null-terminated, so a key containing
-                            // a null byte is cut short here rather than
-                            // truncating the whole message at what()
-                            tokens.emplace_back(element.first.data());
+                            tokens.emplace_back(element.first.c_str());
                            break;
                        }
                    }
@@ -290,5 +287,5 @@ class other_error : public exception
 NLOHMANN_JSON_NAMESPACE_END

 #if defined(__clang__)
-    JSON_HEDLEY_DIAGNOSTIC_POP
+    #pragma clang diagnostic pop
 #endif
@@ -114,9 +114,7 @@ std::size_t hash(const BasicJsonType& j)
            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
            for (const auto byte : j.get_binary())
            {
-                // the cast is needed for binary types whose value type is not
-                // an integer (e.g., std::byte)
-                seed = combine(seed, std::hash<std::uint8_t> {}(static_cast<std::uint8_t>(byte)));
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
            }
            return seed;
        }
@@ -155,31 +155,11 @@ class input_stream_adapter

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

@@ -191,7 +171,7 @@ class iterator_input_adapter
    // in wide_string_input_adapter, which does not expose this).
    static constexpr bool supports_seek =
        std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-        && sentinel_is_sized
+        && std::is_same<IteratorType, SentinelType>::value
        && sizeof(char_type) == 1;

    iterator_input_adapter(IteratorType first, SentinelType last)
@@ -239,60 +219,30 @@ class iterator_input_adapter
  private:
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
-    // library iterators such as those of std::vector and std::string). The
-    // available element count must also be computable in O(1), hence
-    // sentinel_is_sized.
-    static constexpr bool iterator_is_contiguous = sentinel_is_sized &&
-#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
+    // library iterators such as those of std::vector and std::string).
+    // Computing the available element count needs either same-type iterators
+    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
+    // e.g. std::counted_iterator paired with std::default_sentinel_t.
+    static constexpr bool iterator_is_contiguous =
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
+        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
+        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
 #else
-        std::is_pointer<IteratorType>::value;
+        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
 #endif

-    // number of unread elements in [current, end)
-    std::size_t remaining_count() const
-    {
-#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        // std::ranges::distance also supports sized sentinels of a different
-        // type (e.g. std::counted_iterator + std::default_sentinel_t)
-        return static_cast<std::size_t>(std::ranges::distance(current, end));
-#else
-        return static_cast<std::size_t>(std::distance(current, end));
-#endif
-    }
-
-  public:
-    // Whether the remaining input is a single contiguous block of 1-byte
-    // elements that the lexer can inspect directly (used for the SWAR string
-    // fast path).
-    static constexpr bool supports_bulk_scan =
-        iterator_is_contiguous && sizeof(char_type) == 1;
-
-    // Pointer to the next unread element; only valid when bulk_remaining() > 0.
-    const char_type* bulk_data() const
-    {
-        return &*current;
-    }
-
-    // Number of unread elements available as one contiguous block.
-    std::size_t bulk_remaining() const
-    {
-        return remaining_count();
-    }
-
-    // Consume @a n elements previously inspected via bulk_data().
-    void bulk_skip(std::size_t n)
-    {
-        std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(n));
-    }
-
-  private:
    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-        const std::size_t available = remaining_count() * sizeof(char_type);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
+        // std::ranges::distance also supports sized sentinels of a different
+        // type (e.g. std::counted_iterator + std::default_sentinel_t)
+        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
+#else
+        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
+#endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -620,46 +570,6 @@ typename iterator_input_adapter_factory<IteratorType, SentinelType>::adapter_typ
    return factory_type::create(first, last);
 }

-// The element type a container's data() points at, cv-qualifiers removed.
-// Ill-formed - and therefore SFINAE-friendly - for types without data().
-template<typename ContainerType>
-using container_data_t = typename std::remove_cv<typename std::remove_pointer <
-                         decltype(std::declval<const ContainerType&>().data()) >::type >::type;
-
-// The container's own element type, cv-qualifiers removed. It is looked up on
-// the bare type so it is also found when ContainerType is deduced as a
-// reference by the forwarding-reference overload below.
-template<typename ContainerType>
-using container_value_t = typename std::remove_cv <
-                          typename std::remove_cv<typename std::remove_reference<ContainerType>::type>::type::value_type >::type;
-
-// Detect a container that stores its elements contiguously as single bytes
-// (std::string, std::vector<char/unsigned char>, std::array<char, N>,
-// std::string_view, ...). Such inputs are wrapped in a pointer-based adapter so
-// they benefit from the contiguous fast paths (bulk string scanning, memcpy for
-// binary formats) in every C++ standard - not only in C++20, where the standard
-// library iterators model std::contiguous_iterator and are detected directly.
-//
-// data() and size() on their own would be duck typing: they say nothing about
-// size() counting the units data() points at, and reading [data(), data() +
-// size()) as bytes would be wrong for a type where it does not. Requiring the
-// container's own value_type to be that same single-byte element ties the two
-// together; every contiguous standard container satisfies it. Anything else
-// keeps the iterator-based adapter, which is always correct - only slower.
-template<typename ContainerType, typename = void>
-struct is_contiguous_byte_container : std::false_type {};
-
-template<typename ContainerType>
-struct is_contiguous_byte_container < ContainerType, void_t <
-    container_data_t<ContainerType>,
-    container_value_t<ContainerType>,
-decltype(std::declval<const ContainerType&>().size()) >>
-            : std::integral_constant < bool,
-        std::is_pointer<decltype(std::declval<const ContainerType&>().data())>::value&&
-        std::is_integral<container_data_t<ContainerType>>::value&&
-        sizeof(container_data_t<ContainerType>) == 1 &&
-        std::is_same<container_data_t<ContainerType>, container_value_t<ContainerType>>::value > {};
-
 // Convenience shorthand from container to iterator
 // Enables ADL on begin(container) and end(container)
 // Encloses the using declarations in namespace for not to leak them to outside scope
@@ -687,32 +597,12 @@ struct container_input_adapter_factory< ContainerType,

 }  // namespace container_input_adapter_factory_impl

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

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

@@ -8,7 +8,6 @@

 #pragma once

-#include <algorithm> // min
 #include <cstddef>
 #include <string> // string
 #include <type_traits> // enable_if_t
@@ -18,7 +17,6 @@
 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/input/lexer.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
-#include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 NLOHMANN_JSON_NAMESPACE_BEGIN

@@ -152,29 +150,6 @@ constexpr std::size_t unknown_size()
    return (std::numeric_limits<std::size_t>::max)();
 }

-/*!
-@brief reserve capacity for @a len elements in array @a arr
-
-Reserving upfront avoids repeated reallocations while the elements are added,
-but the reservation is capped so a bogus/hostile length (which is not bounded
-by max_size(), unlike e.g. std::vector) cannot trigger an oversized allocation
-for a small or truncated input.
-
-The overload below is selected for array types without reserve() (e.g.,
-std::deque), which are then left untouched.
-*/
-template<typename ArrayType>
-auto reserve_array(ArrayType& arr, std::size_t len, priority_tag<1> /*unused*/)
-> decltype(arr.reserve(len), void())
-{
-    constexpr std::size_t reserve_cap = 16384;
-    arr.reserve((std::min)(len, reserve_cap));
-}
-
-template<typename ArrayType>
-inline void reserve_array(ArrayType& /*arr*/, std::size_t /*len*/, priority_tag<0> /*unused*/)
-{}
-
 /*!
@brief SAX implementation to create a JSON value from SAX events

@@ -247,16 +222,12 @@ class json_sax_dom_parser

    bool string(string_t& val)
    {
-        // json_sax documents that the passed value may be moved from,
-        // so hand the buffer over instead of copying it
-        handle_value(std::move(val));
+        handle_value(val);
        return true;
    }

    bool binary(binary_t& val)
    {
-        // json_sax documents that the passed value may be moved from,
-        // so hand the buffer over instead of copying it
        handle_value(std::move(val));
        return true;
    }
@@ -330,11 +301,6 @@ class json_sax_dom_parser
            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

-        if (len != detail::unknown_size())
-        {
-            reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
-        }
-
        return true;
    }

@@ -566,16 +532,12 @@ class json_sax_dom_callback_parser

    bool string(string_t& val)
    {
-        // json_sax documents that the passed value may be moved from,
-        // so hand the buffer over instead of copying it
-        handle_value(std::move(val));
+        handle_value(val);
        return true;
    }

    bool binary(binary_t& val)
    {
-        // json_sax documents that the passed value may be moved from,
-        // so hand the buffer over instead of copying it
        handle_value(std::move(val));
        return true;
    }
@@ -586,11 +548,6 @@ class json_sax_dom_callback_parser
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
        keep_stack.push_back(keep);

-        // the key this object will be stored under, read before handle_value()
-        // may consume it; kept in lockstep with ref_stack so end_object() can
-        // find the object in its parent again
-        container_key_stack.push_back(current_key());
-
        auto val = handle_value(BasicJsonType::value_t::object, true);
        ref_stack.push_back(val.second);

@@ -624,9 +581,6 @@ class json_sax_dom_callback_parser
        // check callback for the key
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
        key_keep_stack.push_back(keep);
-        // remember the key so a rejected value can be erased without searching
-        // the object for it (kept in lockstep with key_keep_stack)
-        key_stack.push_back(val);

        // add discarded value at the given key and store the reference for later
        if (keep && ref_stack.back())
@@ -668,16 +622,13 @@ class json_sax_dom_callback_parser

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
-        JSON_ASSERT(!container_key_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();
-        const string_t object_key = std::move(container_key_stack.back());
-        container_key_stack.pop_back();

        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
        {
            // remove discarded value
-            remove_discarded_value(*ref_stack.back(), object_key);
+            remove_discarded_value(*ref_stack.back());
        }

        return true;
@@ -688,9 +639,6 @@ class json_sax_dom_callback_parser
        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
        keep_stack.push_back(keep);

-        // see start_object()
-        container_key_stack.push_back(current_key());
-
        auto val = handle_value(BasicJsonType::value_t::array, true);
        ref_stack.push_back(val.second);

@@ -713,11 +661,6 @@ class json_sax_dom_callback_parser
            {
                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
            }
-
-            if (len != detail::unknown_size())
-            {
-                reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
-            }
        }

        return true;
@@ -758,11 +701,8 @@ class json_sax_dom_callback_parser

        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(!keep_stack.empty());
-        JSON_ASSERT(!container_key_stack.empty());
        ref_stack.pop_back();
        keep_stack.pop_back();
-        const string_t object_key = std::move(container_key_stack.back());
-        container_key_stack.pop_back();

        // remove discarded value
        if (!ref_stack.empty() && ref_stack.back())
@@ -776,7 +716,7 @@ class json_sax_dom_callback_parser
                // the array is either still stored under its key or was never
                // stored, leaving the placeholder key() wrote; both show up as
                // a discarded member of the parent object
-                remove_discarded_value(*ref_stack.back(), object_key);
+                remove_discarded_value(*ref_stack.back());
            }
        }

@@ -869,56 +809,15 @@ class json_sax_dom_callback_parser
    }
 #endif

-    /*!
-    @brief the key the value now being handled will be stored under
-
-    Empty unless the enclosing container is an object, in which case it is the
-    key of the pending key() event. Read before handle_value() consumes that
-    key, so it is also correct when the value never reaches its parent.
-    */
-    string_t current_key() const
+    /// remove the discarded value the callback rejected from its parent
+    static void remove_discarded_value(BasicJsonType& parent)
    {
-        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object()
-                && !key_stack.empty())
+        for (auto it = parent.begin(); it != parent.end(); ++it)
        {
-            return key_stack.back();
-        }
-        return string_t{};
-    }
-
-    /*!
-    @brief remove the discarded value the callback rejected from its parent
-
-    A rejected value can only ever be the one most recently added to @a parent:
-    the last element of an array, or the placeholder key() stored under @a key
-    in an object. Looking there directly makes this O(1) resp. O(log n), where
-    searching @a parent for it made a filtering parse quadratic in the number of
-    members of a single container.
-
-    Finding no discarded value there means none was stored in the first place -
-    the callback rejected the value before it reached its parent - so there is
-    nothing to remove.
-
-    @param[in,out] parent  the container to remove the rejected value from
-    @param[in] key  the key the value was stored under; unused for arrays
-    */
-    static void remove_discarded_value(BasicJsonType& parent, const string_t& key)
-    {
-        if (parent.is_array())
-        {
-            auto& array = *parent.m_data.m_value.array;
-            if (!array.empty() && array.back().is_discarded())
+            if (it->is_discarded())
            {
-                array.pop_back();
-            }
-        }
-        else if (parent.is_object())
-        {
-            auto& object = *parent.m_data.m_value.object;
-            const auto it = object.find(key);
-            if (it != object.end() && it->second.is_discarded())
-            {
-                object.erase(it);
+                parent.erase(it);
+                break;
            }
        }
    }
@@ -968,14 +867,11 @@ class json_sax_dom_callback_parser
            if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object())
            {
                JSON_ASSERT(!key_keep_stack.empty());
-                JSON_ASSERT(!key_stack.empty());
                const bool placeholder_stored = key_keep_stack.back();
                key_keep_stack.pop_back();
-                const string_t key = std::move(key_stack.back());
-                key_stack.pop_back();
                if (placeholder_stored)
                {
-                    remove_discarded_value(*ref_stack.back(), key);
+                    remove_discarded_value(*ref_stack.back());
                }
            }
            return {false, nullptr};
@@ -1008,10 +904,8 @@ class json_sax_dom_callback_parser
        JSON_ASSERT(ref_stack.back()->is_object());
        // check if we should store an element for the current key
        JSON_ASSERT(!key_keep_stack.empty());
-        JSON_ASSERT(!key_stack.empty());
        const bool store_element = key_keep_stack.back();
        key_keep_stack.pop_back();
-        key_stack.pop_back();

        if (!store_element)
        {
@@ -1031,12 +925,6 @@ class json_sax_dom_callback_parser
    std::vector<bool> keep_stack {}; // NOLINT(readability-redundant-member-init)
    /// stack to manage which object keys to keep
    std::vector<bool> key_keep_stack {}; // NOLINT(readability-redundant-member-init)
-    /// the keys key() stored a placeholder for, in lockstep with key_keep_stack
-    std::vector<string_t> key_stack {}; // NOLINT(readability-redundant-member-init)
-    /// for each open container, the key it is stored under in its parent
-    /// object, in lockstep with ref_stack; unused where the parent is not an
-    /// object
-    std::vector<string_t> container_key_stack {}; // NOLINT(readability-redundant-member-init)
    /// helper to hold the reference for the next object element
    BasicJsonType* object_element = nullptr;
    /// whether a syntax error occurred
@@ -19,9 +19,7 @@
 #include <vector> // vector

 #include <nlohmann/detail/input/input_adapters.hpp>
-#include <nlohmann/detail/input/number_parse.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
-#include <nlohmann/detail/input/string_scan.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>

@@ -127,25 +125,6 @@ constexpr bool input_adapter_supports_seek(std::false_type /*detected*/)
    return false;
 }

-// Detect whether an input adapter exposes a contiguous byte block that the
-// lexer can scan directly (see iterator_input_adapter::supports_bulk_scan).
-// Adapters without the flag - file, stream, wide-string, user-defined - fall
-// back to the character-at-a-time string scanner.
-template<typename InputAdapterType>
-using detect_supports_bulk_scan = decltype(InputAdapterType::supports_bulk_scan);
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_bulk_scan(std::true_type /*detected*/)
-{
-    return InputAdapterType::supports_bulk_scan;
-}
-
-template<typename InputAdapterType>
-constexpr bool input_adapter_supports_bulk_scan(std::false_type /*detected*/)
-{
-    return false;
-}
-
 /*!
@brief lexical analysis

@@ -167,22 +146,13 @@ class lexer : public lexer_base<BasicJsonType>
    static constexpr bool lazy_token_string =
        input_adapter_supports_seek<InputAdapterType>(is_detected<detect_supports_seek, InputAdapterType> {});

-    /// whether string scanning may bulk-consume runs of ordinary characters
-    /// directly from a contiguous input buffer (SWAR fast path). This requires
-    /// the token to be reconstructible lazily (lazy_token_string), so bypassing
-    /// the per-character capture in get() cannot lose error diagnostics.
-    static constexpr bool bulk_scan =
-        lazy_token_string
-        && input_adapter_supports_bulk_scan<InputAdapterType>(is_detected<detect_supports_bulk_scan, InputAdapterType> {});
-
  public:
    using token_type = typename lexer_base<BasicJsonType>::token_type;

-    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false, bool discard_number_values_ = false) noexcept
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
        : ia(std::move(adapter))
        , ignore_comments(ignore_comments_)
        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
-        , discard_number_values(discard_number_values_)
    {}

    // deleted because of pointer members
@@ -295,40 +265,6 @@ class lexer : public lexer_base<BasicJsonType>
        return true;
    }

-    /// contiguous input: bulk-append the run of ordinary characters and complete
-    /// well-formed UTF-8 sequences starting at the current read position, leaving
-    /// the first byte that needs individual handling (the closing quote, an
-    /// escape, a control character, or an ill-formed UTF-8 byte) for get()
-    void scan_string_bulk(std::true_type /*bulk*/)
-    {
-        // a pending unget must be consumed through the normal path first
-        if (next_unget)
-        {
-            return;
-        }
-        const std::size_t remaining = ia.bulk_remaining();
-        if (remaining == 0)
-        {
-            return;
-        }
-        const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
-
-        const std::size_t pos = string_bulk_run(data, remaining);
-        if (pos == 0)
-        {
-            return;
-        }
-        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), pos);
-        ia.bulk_skip(pos);
-        // the run contains no newline (all bytes < 0x20 are treated as special),
-        // so only the flat character counters advance
-        position.chars_read_total += pos;
-        position.chars_read_current_line += pos;
-    }
-
-    /// streaming input: no bulk fast path
-    void scan_string_bulk(std::false_type /*bulk*/) const noexcept {}
-
    /*!
    @brief scan a string literal

@@ -354,10 +290,6 @@ class lexer : public lexer_base<BasicJsonType>

        while (true)
        {
-            // bulk-consume ordinary characters from contiguous input, then
-            // handle the next special byte through the switch below
-            scan_string_bulk(std::integral_constant<bool, bulk_scan> {});
-
            // get the next character
            switch (get())
            {
@@ -1076,12 +1008,6 @@ class lexer : public lexer_base<BasicJsonType>
        // changed if minus sign, decimal point, or exponent is read
        token_type number_type = token_type::value_unsigned;

-        // offset just past the last mantissa byte in token_buffer (i.e. the
-        // index of 'e'/'E', or the whole token when there is no exponent).
-        // convert_number() uses it to count significant digits; npos means
-        // "not seen an exponent yet" and is resolved at scan_number_done
-        std::size_t mantissa_end = std::string::npos;
-
        // state (init): we just found out we need to scan a number
        switch (current)
        {
@@ -1267,9 +1193,6 @@ scan_number_decimal2:
 scan_number_exponent:
        // we just parsed an exponent
        number_type = token_type::value_float;
-        // this label is reached only right after the 'e'/'E' was appended (from
-        // the zero, any1, and decimal2 states), so the mantissa ends before it
-        mantissa_end = token_buffer.size() - 1;
        switch (get())
        {
            case '+':
@@ -1356,199 +1279,45 @@ scan_number_done:
        // we are done scanning a number)
        unget();

-        // no exponent was scanned: the mantissa spans the whole token
-        if (mantissa_end == std::string::npos)
-        {
-            mantissa_end = token_buffer.size();
-        }
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;

-        return convert_number(number_type, mantissa_end);
-    }
-
-    /*!
-    @brief convert an already-validated integer token to its value
-
-    The digit sequence in [first, last) has been validated by the caller, so a
-    dedicated parser can avoid the locale/errno overhead of std::strtoull.
-
-    @return the token type on success; token_type::uninitialized if @a
-            number_type is not an integer type or the value does not fit, in
-            which case the caller falls back to the floating-point conversion
-            (matching the previous std::strtoull/std::strtoll behavior)
-    */
-    token_type convert_integer(token_type number_type, const char* first, const char* last)
-    {
+        // try to parse integers first and fall back to floats
        if (number_type == token_type::value_unsigned)
        {
-            if (parse_integer_unsigned(first, last, value_unsigned))
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
            {
-                return token_type::value_unsigned;
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
            }
        }
        else if (number_type == token_type::value_integer)
        {
-            if (parse_integer_signed(first, last, value_integer))
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
            {
-                return token_type::value_integer;
-            }
-        }
-
-        return token_type::uninitialized;
-    }
-
-    /*!
-    @brief check whether Clinger's fast path can still succeed for this token
-
-    parse_float_fast() needs a significand below 2^53. A mantissa with 17 or
-    more significant digits is at least 10^16 and therefore always exceeds it,
-    so calling the fast path would walk the token one extra time only to
-    decline before strtod has to run anyway.
-
-    Significant digits are the mantissa's digits from the first nonzero one on;
-    the sign, the decimal point, leading zeros, and the exponent do not count.
-    The answer is derived from indices - the digits are not scanned again - so
-    this stays off the hot path of the number scanners.
-
-    @param[in] mantissa_end  offset just past the last mantissa byte in
-                             token_buffer
-    @return false if parse_float_fast() is guaranteed to decline
-    */
-    bool mantissa_fits_clinger(std::size_t mantissa_end) const
-    {
-        // 10^16 already exceeds 2^53, so 17 digits can never fit
-        constexpr std::size_t limit = 17;
-
-        const std::size_t neg = (!token_buffer.empty() && token_buffer[0] == '-') ? 1u : 0u;
-        const std::size_t has_dot = (decimal_point_position != std::string::npos) ? 1u : 0u;
-        // the JSON grammar restricts the integer part to "0" or [1-9][0-9]*, so
-        // a leading zero can only be a lone "0", which is not significant
-        const std::size_t lead_zero = (token_buffer[neg] == '0') ? 1u : 0u;
-        JSON_ASSERT(mantissa_end >= neg + has_dot + lead_zero);
-        std::size_t digits = mantissa_end - neg - has_dot - lead_zero;
-
-        if (JSON_HEDLEY_LIKELY(digits < limit))
-        {
-            return true;
-        }
-
-        // Only a number below 1 can carry further insignificant zeros, and only
-        // while the count stays at the limit does removing them change the
-        // answer - so this loop is skipped for all but a few tokens. Note
-        // token_buffer holds the locale's decimal point, so the fraction is
-        // located through decimal_point_position rather than by searching '.'.
-        if (lead_zero != 0)
-        {
-            JSON_ASSERT(has_dot != 0); // an integer "0" cannot reach the limit
-            for (std::size_t i = decimal_point_position + 1;
-                    digits >= limit && i < mantissa_end && token_buffer[i] == '0'; ++i)
-            {
-                --digits;
-            }
-        }
-
-        return digits < limit;
-    }
-
-    /*!
-    @brief convert the number text in token_buffer to its value and token type
-
-    The digit sequence in token_buffer has already been validated (by the
-    scan_number() state machine or by the contiguous fast path) and holds the
-    locale decimal point in place of '.'. Integers are parsed first and fall
-    back to floating point on overflow. This is shared so both scanners produce
-    identical results.
-
-    @param[in] mantissa_end  offset just past the last mantissa byte in
-                             token_buffer (the index of 'e'/'E', or
-                             token_buffer.size() when there is no exponent);
-                             used to skip Clinger's fast path when it cannot
-                             possibly succeed - see mantissa_fits_clinger()
-    */
-    token_type convert_number(token_type number_type, std::size_t mantissa_end)
-    {
-        // If the caller does not need the converted value (only whether the
-        // input is syntactically valid; see json_sax_acceptor/accept()), an
-        // unsigned/integer token can be reported without calling
-        // strtoull()/strtoll() at all, *provided* we can already tell from
-        // the digit count alone that the conversion cannot overflow 64 bits.
-        // Such tokens are always finite and are accepted unconditionally by
-        // the parser regardless of their actual value (parser::sax_parse_internal()
-        // never checks finiteness for value_unsigned/value_integer), so the
-        // classification below is all that is needed.
-        //
-        // A decimal number with up to 18 digits is always representable in
-        // both std::uint64_t and std::int64_t (18 nines is ~1e18, well below
-        // both UINT64_MAX ~1.8e19 and INT64_MAX ~9.2e18), so strtoull()/strtoll()
-        // could not have set errno to ERANGE for it. Numbers with more digits
-        // (rare in practice) fall through to the exact code below, unchanged,
-        // so their handling -- including reclassification to value_float when
-        // the value overflows 64 bits, and rejection when it is not even
-        // finite as a double -- is bit-for-bit identical to before this
-        // optimization.
-        //
-        // Note this reasons about std::uint64_t/std::int64_t, not about
-        // number_unsigned_t/number_integer_t (BasicJsonType's own, possibly
-        // narrower, template parameters -- e.g. std::uint32_t). That is fine
-        // *only* because discard_number_values is exclusively set by
-        // accept() (see json.hpp), and accept() always parses through the
-        // library's own json_sax_acceptor -- never a user-supplied SAX
-        // consumer -- whose number_unsigned()/number_integer()/number_float()
-        // callbacks unconditionally discard their argument and return true.
-        // So for every caller that can reach this branch, neither the token
-        // classification below nor the eventual (possibly narrowed, and on
-        // this fast path left stale/unset) value_unsigned/value_integer is
-        // ever consulted -- an unsigned/integer token is accepted outright,
-        // and even a >18-digit token that this fast path deliberately falls
-        // through for is, once reclassified to value_float, still finite
-        // (and thus accepted) for any digit count that fits in number_unsigned_t
-        // or number_integer_t regardless of that type's width. If this
-        // function is ever taught to run with discard_number_values true for
-        // a caller that *does* read the converted value, this reasoning (and
-        // the fast path below) would need to be revisited.
-        if (discard_number_values)
-        {
-            constexpr std::size_t safe_digit_count = 18;
-            if (number_type == token_type::value_unsigned && token_buffer.size() <= safe_digit_count)
-            {
-                return token_type::value_unsigned;
-            }
-            if (number_type == token_type::value_integer && token_buffer.size() - 1 <= safe_digit_count)
-            {
-                return token_type::value_integer;
-            }
-        }
-
-        const char* const num_begin = token_buffer.data();
-        const char* const num_end = num_begin + token_buffer.size();
-
-        if (number_type != token_type::value_float)
-        {
-            const token_type integer_result = convert_integer(number_type, num_begin, num_end);
-            if (integer_result != token_type::uninitialized)
-            {
-                return integer_result;
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
            }
        }

        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Prefer std::from_chars
-        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
-        // otherwise the exact Clinger fast path (double only); otherwise the
-        // locale-aware strtof/strtod.
-        if (parse_float_from_chars(num_begin, num_end, value_float))
-        {
-            return token_type::value_float;
-        }
-        // Skipping a fast path that cannot succeed is lossless and saves a full
-        // extra pass over the token's bytes, which otherwise shows up on
-        // high-precision inputs such as canada.json
-        if (mantissa_fits_clinger(mantissa_end)
-                && parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
-        {
-            return token_type::value_float;
-        }
-
-        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        // integer conversion above failed
        strtof(value_float, token_buffer.data(), &endptr);

        // we checked the number format before
@@ -1557,158 +1326,6 @@ scan_number_done:
        return token_type::value_float;
    }

-    /*!
-    @brief contiguous fast path for scanning a number
-
-    Parses the whole number token straight from the input buffer, avoiding the
-    per-character get()/add() of scan_number(). On success it fills token_buffer
-    (with the locale decimal point substituted, as scan_number() does) and
-    returns the token type. On anything it does not fully recognize as a
-    well-formed number it makes no state change and returns
-    token_type::uninitialized, so the caller falls back to scan_number(), which
-    then produces the exact diagnostic. @a current is the first digit or the
-    leading minus (already read); the remaining bytes are taken from the adapter.
-    */
-    token_type scan_number_bulk_contiguous()
-    {
-        // a pending unget offsets the buffer position from current; fall back
-        if (next_unget)
-        {
-            return token_type::uninitialized;
-        }
-        const std::size_t rem = ia.bulk_remaining();
-        if (rem == 0)
-        {
-            // the first digit is the last input byte; let scan_number() finish
-            return token_type::uninitialized;
-        }
-        // the byte before the next unread one is current (contiguous input)
-        const char* const data = reinterpret_cast<const char*>(ia.bulk_data()) - 1;
-        const std::size_t avail = rem + 1;
-
-        // validate + classify the number extent (mirrors scan_number()'s grammar)
-        std::size_t i = 0;
-        std::size_t dot_index = std::string::npos;
-        token_type number_type = token_type::value_unsigned;
-        if (data[0] == '-')
-        {
-            number_type = token_type::value_integer;
-            i = 1;
-            if (i >= avail)
-            {
-                return token_type::uninitialized;
-            }
-        }
-        if (data[i] == '0')
-        {
-            ++i;
-        }
-        else if (data[i] >= '1' && data[i] <= '9')
-        {
-            ++i;
-            while (i < avail && data[i] >= '0' && data[i] <= '9')
-            {
-                ++i;
-            }
-        }
-        else
-        {
-            return token_type::uninitialized;
-        }
-        if (i < avail && data[i] == '.')
-        {
-            number_type = token_type::value_float;
-            dot_index = i;
-            ++i;
-            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
-            {
-                return token_type::uninitialized;
-            }
-            while (i < avail && data[i] >= '0' && data[i] <= '9')
-            {
-                ++i;
-            }
-        }
-        // the mantissa ends here, whether or not an exponent part follows
-        const std::size_t mantissa_end = i;
-        if (i < avail && (data[i] == 'e' || data[i] == 'E'))
-        {
-            number_type = token_type::value_float;
-            ++i;
-            if (i < avail && (data[i] == '+' || data[i] == '-'))
-            {
-                ++i;
-            }
-            if (i >= avail || !(data[i] >= '0' && data[i] <= '9'))
-            {
-                return token_type::uninitialized;
-            }
-            while (i < avail && data[i] >= '0' && data[i] <= '9')
-            {
-                ++i;
-            }
-        }
-        const std::size_t len = i;
-
-        // reset() records where this token starts (for diagnostics), so it has
-        // to run before the input position advances below
-        reset();
-
-        // An integer token needs no token_buffer: the SAX callbacks for
-        // number_integer/number_unsigned take only the value, and the overflow
-        // diagnostic rebuilds the text from the input. Convert straight from the
-        // input buffer and leave token_buffer empty. (JSON_DIAGNOSTIC_POSITIONS
-        // derives a number's start position from get_string().size(), so there
-        // the token still has to be materialized.)
-#if !JSON_DIAGNOSTIC_POSITIONS
-        if (number_type != token_type::value_float)
-        {
-            const token_type integer_result = convert_integer(number_type, data, data + len);
-            if (JSON_HEDLEY_LIKELY(integer_result != token_type::uninitialized))
-            {
-                ia.bulk_skip(len - 1);
-                position.chars_read_total += (len - 1);
-                position.chars_read_current_line += (len - 1);
-                return integer_result;
-            }
-            // The value does not fit an integer, so this token converts as a
-            // float. Recording that here keeps convert_number() below from
-            // repeating the integer attempt that just failed.
-            number_type = token_type::value_float;
-        }
-#endif
-
-        // materialize the token exactly as scan_number() would, substituting the
-        // locale decimal point so convert_number()'s strtof fallback stays valid.
-        // reset() already cleared token_buffer, so append() fills it (assign() is
-        // avoided because custom string_t types need not provide it)
-        token_buffer.append(reinterpret_cast<const typename string_t::value_type*>(data), len);
-        if (dot_index != std::string::npos)
-        {
-            token_buffer[dot_index] = static_cast<typename string_t::value_type>(decimal_point_char);
-            decimal_point_position = dot_index;
-        }
-
-        ia.bulk_skip(len - 1);
-        position.chars_read_total += (len - 1);
-        position.chars_read_current_line += (len - 1);
-
-        return convert_number(number_type, mantissa_end);
-    }
-
-    /// contiguous input: try the number fast path, else the byte-path scanner
-    token_type scan_number_dispatch(std::true_type /*bulk*/)
-    {
-        const token_type t = scan_number_bulk_contiguous();
-        return (t != token_type::uninitialized) ? t : scan_number();
-    }
-
-    /// streaming input: always use the byte-path scanner
-    token_type scan_number_dispatch(std::false_type /*bulk*/)
-    {
-        return scan_number();
-    }
-
    /*!
    @param[in] literal_text  the literal text to expect
    @param[in] length        the length of the passed literal text
@@ -1776,7 +1393,8 @@ scan_number_done:
    */
    char_int_type get()
    {
-        advance_position();
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;

        if (next_unget)
        {
@@ -1788,23 +1406,6 @@ scan_number_done:
            current = ia.get_character();
        }

-        return track_after_read();
-    }
-
-    /// shared head of get() / get_ignoring_pending_unget(): bump the
-    /// per-character position counters (line-count-on-'\n' bookkeeping is
-    /// handled afterwards, in track_after_read(), once `current` is known)
-    void advance_position() noexcept
-    {
-        ++position.chars_read_total;
-        ++position.chars_read_current_line;
-    }
-
-    /// shared tail of get() / get_ignoring_pending_unget(): capture the
-    /// character for error messages (if needed) and update line/column
-    /// bookkeeping for the character now in `current`
-    char_int_type track_after_read()
-    {
        // seekable adapters reconstruct the token lazily on error (see
        // get_token_string), so the eager per-character copy is skipped
        capture_char(std::integral_constant<bool, lazy_token_string> {});
@@ -1812,38 +1413,12 @@ scan_number_done:
        if (current == '\n')
        {
            ++position.lines_read;
-            // remember the column the newline was read at: chars_read_current_line
-            // is about to be cleared, and a matching unget() cannot reconstruct it
-            chars_read_before_newline = position.chars_read_current_line;
            position.chars_read_current_line = 0;
        }

        return current;
    }

-    /*!
-    @brief like get(), but for call sites that can prove no unget() is pending
-
-    get() has to check the `next_unget` flag on every call, because a
-    previous token may have ended with unget() (e.g. scan_number() always
-    ungets the character that terminated the number, so the next call to
-    scan() can see it again). skip_whitespace() reads that first,
-    possibly-ungotten character via a plain get(), but every further
-    character it reads is guaranteed to be a fresh read: nothing between
-    those calls invokes unget(). This variant skips the (otherwise always
-    false) next_unget branch for those calls; it is not a general
-    replacement for get().
-    */
-    char_int_type get_ignoring_pending_unget()
-    {
-        JSON_ASSERT(!next_unget);
-
-        advance_position();
-        current = ia.get_character();
-
-        return track_after_read();
-    }
-
    /// seekable adapter: nothing to capture, the token is rebuilt on error
    void capture_char(std::true_type /*lazy*/) const noexcept {}

@@ -1871,20 +1446,12 @@ scan_number_done:
        --position.chars_read_total;

        // in case we "unget" a newline, we have to also decrement the lines_read
-        // and restore the column that get() cleared when it saw the newline;
-        // chars_read_current_line == 0 can only mean the last get() read one
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
-
-            // chars_read_before_newline counts the newline itself, which is the
-            // character being ungotten, hence the -1
-            position.chars_read_current_line = (chars_read_before_newline > 0)
-                                               ? chars_read_before_newline - 1
-                                               : 0;
        }
        else
        {
@@ -2045,37 +1612,13 @@ scan_number_done:
        return true;
    }

-    /// whether `current` is one of the four JSON whitespace characters
-    bool current_is_whitespace() const noexcept
-    {
-        return current == ' ' || current == '\t' || current == '\n' || current == '\r';
-    }
-
    void skip_whitespace()
    {
-        // the first character may be a pending unget() left over from the
-        // previous token (see get_ignoring_pending_unget()); every
-        // subsequent character read by this loop is guaranteed fresh, since
-        // nothing below calls unget()
-        get();
-
-        if (!current_is_whitespace())
-        {
-            return;
-        }
-
-        // this is written as an if-guarded do-while (rather than a plain
-        // while loop) because that shape is what lets both GCC and Clang
-        // keep the input adapter's read pointer in a register across
-        // iterations; the equivalent while-loop measurably defeated that
-        // optimization in testing, turning long whitespace runs (e.g. the
-        // indentation of pretty-printed JSON) from a register-only loop
-        // into one that reloads the pointer from memory every character
        do
        {
-            get_ignoring_pending_unget();
+            get();
        }
-        while (current_is_whitespace());
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
    }

    token_type scan()
@@ -2151,7 +1694,7 @@ scan_number_done:
            case '7':
            case '8':
            case '9':
-                return scan_number_dispatch(std::integral_constant<bool, bulk_scan> {});
+                return scan_number();

            // end of input (the null byte is needed when parsing from
            // string literals)
@@ -2182,10 +1725,6 @@ scan_number_done:
    /// the start position of the current token
    position_t position {};

-    /// the value chars_read_current_line had when the last newline was read, so
-    /// that unget() can restore the column instead of leaving it at 0
-    std::size_t chars_read_before_newline = 0;
-
    /// raw input token string for error messages; only populated for streaming
    /// adapters (seekable adapters reconstruct it lazily via token_string_start)
    std::vector<char_type> token_string {};
@@ -2215,13 +1754,6 @@ scan_number_done:
    const char_int_type decimal_point_char = '.';
    /// the position of the decimal point in the input
    std::size_t decimal_point_position = std::string::npos;
-
-    /// whether the caller (e.g. accept()/json_sax_acceptor) only needs the
-    /// token classification and never looks at the converted numeric value;
-    /// when set, scan_number() may skip strtoull()/strtoll() for
-    /// value_unsigned/value_integer tokens whose digit count guarantees they
-    /// fit into 64 bits (see scan_number())
-    const bool discard_number_values = false;
 };

 }  // namespace detail
@@ -1,302 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <array> // array
-#include <cfloat> // FLT_EVAL_METHOD
-#include <cstddef> // size_t
-#include <cstdint> // int64_t, uint64_t
-#include <limits> // numeric_limits
-
-#include <nlohmann/detail/macro_scope.hpp>
-
-// std::from_chars lives in <charconv>, but being in C++17 mode does not
-// guarantee the header exists: GCC 7 sets __cplusplus to C++17 yet ships no
-// <charconv> (added in GCC 8; floating-point support in GCC 11). Guard the
-// include with __has_include so such toolchains fall back to the scalar path.
-#if defined(JSON_HAS_CPP_17) && defined(__has_include)
-    #if __has_include(<charconv>)
-        #include <charconv> // from_chars (only used when __cpp_lib_to_chars is defined)
-        #include <system_error> // errc
-    #endif
-#endif
-
-// This file contains the value-conversion helpers used by the lexer to turn an
-// already-validated number token into a value, without the locale/errno
-// overhead of std::strtoull/std::strtod. They are free functions so the lexer
-// stays focused on scanning; see lexer::convert_number().
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-/*!
-@brief fast integer parser for an already-validated unsigned integer
-
-The number scanner has already checked that [first, last) is a valid JSON
-integer, so this only needs to accumulate the digits and detect overflow. This
-avoids the locale/errno machinery of std::strtoull, which dominates
-integer-heavy inputs.
-
-@param[in]  first   pointer to the first character (a digit)
-@param[in]  last    pointer past the last character
-@param[out] value   the parsed value on success
-@return true if the value fit into @a NumberUnsignedType; false on overflow, in
-        which case the caller falls back to floating-point parsing (matching the
-        previous std::strtoull behavior)
-*/
-template<typename NumberUnsignedType>
-bool parse_integer_unsigned(const char* first, const char* last, NumberUnsignedType& value) noexcept
-{
-    // accumulate in the widest unsigned type used by the previous strtoull
-    // path so the overflow behavior is unchanged for custom number types
-    std::uint64_t x = 0;
-    constexpr std::uint64_t cutoff = (std::numeric_limits<std::uint64_t>::max)() / 10u;
-    constexpr std::uint64_t cutlim = (std::numeric_limits<std::uint64_t>::max)() % 10u;
-    for (const char* p = first; p != last; ++p)
-    {
-        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
-        if (JSON_HEDLEY_UNLIKELY(x > cutoff || (x == cutoff && digit > cutlim)))
-        {
-            return false;
-        }
-        x = (x * 10u) + digit;
-    }
-    value = static_cast<NumberUnsignedType>(x);
-    // reject values that do not round-trip into a narrower NumberUnsignedType
-    return static_cast<std::uint64_t>(value) == x;
-}
-
-/*!
-@brief fast integer parser for an already-validated negative integer
-
-@param[in]  first   pointer to the leading '-'
-@param[in]  last    pointer past the last character
-@param[out] value   the parsed (negative) value on success
-@return true on success; false on overflow (caller falls back to float)
-*/
-template<typename NumberIntegerType>
-bool parse_integer_signed(const char* first, const char* last, NumberIntegerType& value) noexcept
-{
-    // the state machine only reaches the signed path via a leading '-'
-    JSON_ASSERT(first != last && *first == '-');
-    std::uint64_t magnitude = 0;
-    // |INT64_MIN| == INT64_MAX + 1; this is the largest admissible magnitude
-    constexpr std::uint64_t limit = static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1u;
-    for (const char* p = first + 1; p != last; ++p)
-    {
-        const auto digit = static_cast<std::uint64_t>(static_cast<unsigned char>(*p) - static_cast<unsigned char>('0'));
-        if (JSON_HEDLEY_UNLIKELY(magnitude > (limit - digit) / 10u))
-        {
-            return false;
-        }
-        magnitude = (magnitude * 10u) + digit;
-    }
-    const std::int64_t x = (magnitude == limit)
-                           ? (std::numeric_limits<std::int64_t>::min)()
-                           : -static_cast<std::int64_t>(magnitude);
-    value = static_cast<NumberIntegerType>(x);
-    // reject values that do not round-trip into a narrower NumberIntegerType
-    return static_cast<std::int64_t>(value) == x;
-}
-
-/*!
-@brief exact fast path for parsing a `double` (Clinger's algorithm)
-
-For the common case - at most 19 significant digits, a decimal exponent in
-[-22, 22], and a significand below 2^53 - the value equals significand *
-10^exp computed in IEEE-754 double arithmetic, which is exact under
-round-to-nearest because both operands are exactly representable. This is the
-same fast path used by fast_float/simdjson; the general cases are left to
-std::strtod. The parser only activates for number_float_t == double; float and
-long double keep the std::strtof/std::strtold paths (see the templated overload
-below).
-
-@param[in]  first          pointer to the first character of the number
-@param[in]  last           pointer past the last character
-@param[in]  decimal_point  the (locale-dependent) decimal point character
-@param[out] out            the parsed value on success
-@return true if the value was parsed exactly; false to fall back to strtod
-*/
-template<typename DecimalPointType>
-bool parse_float_fast(const char* first, const char* last, DecimalPointType decimal_point, double& out) noexcept
-{
-#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
-    // Clinger's fast path is only exact when double operations are evaluated in
-    // true double precision. On platforms that keep intermediates in extended
-    // precision (e.g. the x87 FPU on 32-bit x86, where FLT_EVAL_METHOD == 2) the
-    // single significand * 10^scale step is double-rounded and can be 1 ULP off,
-    // so decline and let the caller fall back to the correctly-rounded
-    // std::from_chars / std::strtod path.
-    static_cast<void>(first);
-    static_cast<void>(last);
-    static_cast<void>(decimal_point);
-    static_cast<void>(out);
-    return false;
-#else
-    static const std::array<double, 23> powers_of_ten =
-    {
-        {
-            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
-            1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
-        }
-    };
-
-    const char* p = first;
-    bool negative = false;
-    if (p != last && (*p == '-' || *p == '+'))
-    {
-        negative = (*p == '-');
-        ++p;
-    }
-
-    std::uint64_t significand = 0;
-    int num_digits = 0;
-    int fractional_digits = 0;
-    bool seen_dot = false;
-    bool any_digit = false;
-    for (; p != last; ++p)
-    {
-        const char c = *p;
-        if (c >= '0' && c <= '9')
-        {
-            any_digit = true;
-            if (JSON_HEDLEY_UNLIKELY(num_digits >= 19))
-            {
-                return false; // significand may not fit into uint64_t
-            }
-            significand = (significand * 10u) + static_cast<std::uint64_t>(c - '0');
-            ++num_digits;
-            fractional_digits += static_cast<int>(seen_dot);
-        }
-        else if (static_cast<DecimalPointType>(c) == decimal_point)
-        {
-            if (JSON_HEDLEY_UNLIKELY(seen_dot))
-            {
-                return false;
-            }
-            seen_dot = true;
-        }
-        else if (c == 'e' || c == 'E')
-        {
-            ++p;
-            break;
-        }
-        else
-        {
-            return false;
-        }
-    }
-    if (JSON_HEDLEY_UNLIKELY(!any_digit))
-    {
-        return false;
-    }
-
-    int exponent = 0;
-    if (p != last) // an exponent part remains
-    {
-        bool exp_negative = false;
-        if (p != last && (*p == '-' || *p == '+'))
-        {
-            exp_negative = (*p == '-');
-            ++p;
-        }
-        bool any_exp_digit = false;
-        for (; p != last; ++p)
-        {
-            if (JSON_HEDLEY_UNLIKELY(*p < '0' || *p > '9'))
-            {
-                return false;
-            }
-            exponent = (exponent * 10) + (*p - '0');
-            any_exp_digit = true;
-            if (JSON_HEDLEY_UNLIKELY(exponent > 9999))
-            {
-                return false;
-            }
-        }
-        if (JSON_HEDLEY_UNLIKELY(!any_exp_digit))
-        {
-            return false;
-        }
-        if (exp_negative)
-        {
-            exponent = -exponent;
-        }
-    }
-
-    const int scale = exponent - fractional_digits;
-    if (JSON_HEDLEY_UNLIKELY(significand >= (static_cast<std::uint64_t>(1) << 53)))
-    {
-        return false; // significand not exactly representable as double
-    }
-
-    auto result = static_cast<double>(significand);
-    if (scale >= 0)
-    {
-        if (JSON_HEDLEY_UNLIKELY(scale > 22))
-        {
-            return false;
-        }
-        result *= powers_of_ten[static_cast<std::size_t>(scale)];
-    }
-    else
-    {
-        if (JSON_HEDLEY_UNLIKELY(-scale > 22))
-        {
-            return false;
-        }
-        result /= powers_of_ten[static_cast<std::size_t>(-scale)];
-    }
-    out = negative ? -result : result;
-    return true;
-#endif
-}
-
-/// fast float path is only exact for `double`; decline for float/long double
-template<typename DecimalPointType, typename FloatType>
-bool parse_float_fast(const char* /*first*/, const char* /*last*/, DecimalPointType /*decimal_point*/, FloatType& /*out*/) noexcept
-{
-    return false;
-}
-
-/*!
-@brief parse a float with std::from_chars (Eisel-Lemire) when available
-
-std::from_chars is locale-independent, correctly rounded, and - via the
-Eisel-Lemire algorithm in modern standard libraries - much faster than strtod
-over the whole value range (not just the Clinger subset). It is used only when
-__cpp_lib_to_chars indicates full floating-point support and only when it
-consumes the entire token ([first, last)); a partial parse means the buffer
-uses a non-'.' locale decimal point, in which case the caller falls back to the
-locale-aware path. An under-/overflow (result_out_of_range) also declines, so
-the caller's strtod fallback supplies the well-defined ±inf/0 result the parser
-expects (side-stepping the P4168 divergence between implementations).
-
-@return true if the value was parsed exactly and fully; false to fall back
-*/
-template<typename FloatType>
-bool parse_float_from_chars(const char* first, const char* last, FloatType& out) noexcept
-{
-    // JSON_HAS_CPP_17 must gate the use as well as the <charconv> include above:
-    // some standard libraries (e.g. libstdc++ 15) define __cpp_lib_to_chars even
-    // in C++14 mode, where <charconv> is not included.
-#if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
-    const auto result = std::from_chars(first, last, out);
-    return result.ec == std::errc() && result.ptr == last;
-#else
-    static_cast<void>(first);
-    static_cast<void>(last);
-    static_cast<void>(out);
-    return false;
-#endif
-}
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
@@ -72,10 +72,9 @@ class parser
                    parser_callback_t<BasicJsonType> cb = nullptr,
                    const bool allow_exceptions_ = true,
                    const bool ignore_comments = false,
-                    const bool ignore_trailing_commas_ = false,
-                    const bool discard_number_values_ = false)
+                    const bool ignore_trailing_commas_ = false)
        : callback(std::move(cb))
-        , m_lexer(std::move(adapter), ignore_comments, discard_number_values_)
+        , m_lexer(std::move(adapter), ignore_comments)
        , allow_exceptions(allow_exceptions_)
        , ignore_trailing_commas(ignore_trailing_commas_)
    {
@@ -1,287 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <cstddef> // size_t
-#include <cstdint> // uint64_t
-#include <cstring> // memcpy
-
-#include <nlohmann/detail/macro_scope.hpp>
-
-// Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
-// dependency: nlohmann/json itself stays header-only and the C++11 scalar
-// validator below is always available; defining JSON_USE_SIMDUTF additionally
-// requires the simdutf headers on the include path and linking the simdutf
-// library. See string_bulk_run().
-//
-// simdutf.h itself requires C++17 - it rejects older standards with an #error -
-// so the backend is only compiled in from C++17 on. Below that the macro has no
-// effect and the scalar validator is used; it accepts and rejects exactly the
-// same input, so only throughput differs. macro_scope.hpp is included above to
-// have JSON_HAS_CPP_17 available for this test.
-#if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
-    #include <simdutf.h>
-#endif
-
-// This file contains the byte-level string-scanning helpers used by the lexer's
-// contiguous fast path. They operate purely on raw bytes (no dependency on the
-// lexer's template parameters) so they are free functions, keeping the lexer
-// itself focused on the state machine; see lexer::scan_string_bulk().
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-// classify a single byte as needing individual string handling: the closing
-// quote, an escape, a control character, or a non-ASCII (UTF-8)
-// lead/continuation byte. Ordinary bytes (0x20..0x7F except '"' and '\\') are
-// copied verbatim, which the bulk scanner does 8 bytes at a time.
-inline bool is_string_special(unsigned char c) noexcept
-{
-    return c == '\"' || c == '\\' || c < 0x20u || c >= 0x80u;
-}
-
-// SWAR helper: return a word whose high bit is set in every byte of @a v that
-// is_string_special(); zero if the 8 bytes are all ordinary.
-inline std::uint64_t swar_string_special(std::uint64_t v) noexcept
-{
-    constexpr std::uint64_t ones = 0x0101010101010101ull;
-    constexpr std::uint64_t high = 0x8080808080808080ull;
-    const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
-    const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
-    const std::uint64_t has_quote     = (q - ones) & ~q & high;
-    const std::uint64_t has_backslash = (b - ones) & ~b & high;
-    const std::uint64_t has_control   = (v - 0x2020202020202020ull) & ~v & high; // < 0x20
-    const std::uint64_t has_non_ascii = v & high;                                // >= 0x80
-    return has_quote | has_backslash | has_control | has_non_ascii;
-}
-
-// return the index of the first is_string_special() byte in [data, data+n), or
-// n if every byte is ordinary; scans 8 bytes at a time
-inline std::size_t find_string_special(const unsigned char* data, std::size_t n) noexcept
-{
-    std::size_t i = 0;
-    for (; i + 8 <= n; i += 8)
-    {
-        std::uint64_t word = 0;
-        std::memcpy(&word, data + i, sizeof(word));
-        if (swar_string_special(word) != 0)
-        {
-            // a special byte is in this word; locate it (endian-agnostic)
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                if (is_string_special(data[i + j]))
-                {
-                    return i + j;
-                }
-            }
-        }
-    }
-    for (; i < n; ++i)
-    {
-        if (is_string_special(data[i]))
-        {
-            return i;
-        }
-    }
-    return n;
-}
-
-// classify a byte as one the serializer must NOT copy verbatim when
-// ensure_ascii is requested: the closing quote, an escape, a control character
-// (< 0x20), DEL (0x7F), or any non-ASCII byte (>= 0x80). Everything else -
-// printable ASCII except '"' and '\\' - is emitted unchanged. Note this differs
-// from is_string_special() only in that 0x7F is also a stop (it is escaped as
-// \u007f under ensure_ascii).
-inline bool is_ascii_copyable(unsigned char c) noexcept
-{
-    return c >= 0x20u && c < 0x7Fu && c != '"' && c != '\\';
-}
-
-// return the index of the first byte in [data, data+n) that is NOT
-// is_ascii_copyable(), or n if every byte can be copied verbatim; scans 8 bytes
-// at a time. Used by the serializer's ensure_ascii fast path.
-inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_t n) noexcept
-{
-    constexpr std::uint64_t ones = 0x0101010101010101ull;
-    constexpr std::uint64_t high = 0x8080808080808080ull;
-    std::size_t i = 0;
-    for (; i + 8 <= n; i += 8)
-    {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
-        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
-        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
-        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
-        const std::uint64_t stop = ((q - ones) & ~q & high)   // == '"'
-                                   | ((b - ones) & ~b & high)  // == '\\'
-                                   | ((d - ones) & ~d & high)  // == 0x7F
-                                   | ((v - 0x2020202020202020ull) & ~v & high) // < 0x20
-                                   | (v & high);               // >= 0x80
-        if (stop != 0)
-        {
-            break;
-        }
-    }
-    for (; i < n; ++i)
-    {
-        if (!is_ascii_copyable(data[i]))
-        {
-            return i;
-        }
-    }
-    return n;
-}
-
-// Validate one UTF-8 sequence at the front of [data, data+avail). Returns its
-// length (2..4) only when the bytes form a *well-formed* sequence using exactly
-// the same ranges as scan_string()'s per-byte switch, so the bulk path accepts
-// precisely what the byte path accepts. Returns 0 for anything that is invalid,
-// incomplete, or that the byte path must diagnose (the caller then defers to
-// that path, keeping error messages unchanged). Lead bytes < 0x80 are handled
-// by the caller and never passed here.
-inline std::size_t validate_one_utf8(const unsigned char* data, std::size_t avail) noexcept
-{
-    const unsigned char c0 = data[0];
-    if (c0 >= 0xC2 && c0 <= 0xDF)  // U+0080..U+07FF
-    {
-        if (avail >= 2 && data[1] >= 0x80 && data[1] <= 0xBF)
-        {
-            return 2;
-        }
-    }
-    else if (c0 == 0xE0)  // U+0800..U+0FFF
-    {
-        if (avail >= 3 && data[1] >= 0xA0 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
-        {
-            return 3;
-        }
-    }
-    else if ((c0 >= 0xE1 && c0 <= 0xEC) || c0 == 0xEE || c0 == 0xEF)  // U+1000..U+CFFF, U+E000..U+FFFF
-    {
-        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF)
-        {
-            return 3;
-        }
-    }
-    else if (c0 == 0xED)  // U+D000..U+D7FF (excludes surrogates)
-    {
-        if (avail >= 3 && data[1] >= 0x80 && data[1] <= 0x9F && data[2] >= 0x80 && data[2] <= 0xBF)
-        {
-            return 3;
-        }
-    }
-    else if (c0 == 0xF0)  // U+10000..U+3FFFF
-    {
-        if (avail >= 4 && data[1] >= 0x90 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
-        {
-            return 4;
-        }
-    }
-    else if (c0 >= 0xF1 && c0 <= 0xF3)  // U+40000..U+FFFFF
-    {
-        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0xBF && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
-        {
-            return 4;
-        }
-    }
-    else if (c0 == 0xF4)  // U+100000..U+10FFFF
-    {
-        if (avail >= 4 && data[1] >= 0x80 && data[1] <= 0x8F && data[2] >= 0x80 && data[2] <= 0xBF && data[3] >= 0x80 && data[3] <= 0xBF)
-        {
-            return 4;
-        }
-    }
-    return 0; // invalid, incomplete, or must be diagnosed by the byte path
-}
-
-// Scalar (C++11) computation of the bulk run length: the number of leading
-// bytes in [data, data+n) that are ordinary ASCII or complete well-formed UTF-8
-// sequences, stopping before the first byte that needs individual handling (the
-// closing quote, an escape, a control character, or an ill-formed/truncated
-// sequence). ASCII is skipped 8 bytes at a time.
-inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t n) noexcept
-{
-    std::size_t pos = 0;
-    while (pos < n)
-    {
-        pos += find_string_special(data + pos, n - pos);
-        if (pos >= n || data[pos] < 0x80u)
-        {
-            break; // end of buffer, or a quote/escape/control byte
-        }
-        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
-        if (seq == 0)
-        {
-            break; // ill-formed or truncated: let the byte path diagnose it
-        }
-        pos += seq;
-    }
-    return pos;
-}
-
-#if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
-// Index of the first quote/escape/control byte in [data, data+n) (non-ASCII
-// bytes are *not* stops here - the whole run is handed to simdutf), or n.
-inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t n) noexcept
-{
-    constexpr std::uint64_t ones = 0x0101010101010101ull;
-    constexpr std::uint64_t high = 0x8080808080808080ull;
-    std::size_t i = 0;
-    for (; i + 8 <= n; i += 8)
-    {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
-        const std::uint64_t q = v ^ 0x2222222222222222ull;
-        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
-        const std::uint64_t hit = ((q - ones) & ~q & high)
-                                  | ((b - ones) & ~b & high)
-                                  | ((v - 0x2020202020202020ull) & ~v & high);
-        if (hit != 0)
-        {
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                const unsigned char c = data[i + j];
-                if (c == '\"' || c == '\\' || c < 0x20u)
-                {
-                    return i + j;
-                }
-            }
-        }
-    }
-    for (; i < n; ++i)
-    {
-        const unsigned char c = data[i];
-        if (c == '\"' || c == '\\' || c < 0x20u)
-        {
-            return i;
-        }
-    }
-    return n;
-}
-#endif
-
-// Backend-dispatched bulk run length. With JSON_USE_SIMDUTF the run up to the
-// next delimiter is validated in one shot by simdutf; on the rare failure the
-// scalar helper recomputes the exact valid prefix so the byte path still
-// produces the precise diagnostic. Without it, the pure scalar path is used.
-inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noexcept
-{
-#if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
-    const std::size_t run = find_string_delimiter(data, n);
-    if (run != 0 && simdutf::validate_utf8(reinterpret_cast<const char*>(data), run))
-    {
-        return run;
-    }
-#endif
-    return scalar_string_bulk_run(data, n);
-}
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
@@ -88,13 +88,8 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci

    iter_impl() = default;
    ~iter_impl() = default;
-    // the exception specification is left to be computed rather than declared:
-    // an array or object type whose iterator is not nothrow move constructible
-    // (std::deque's is not before libstdc++ 11) would make a declared noexcept
-    // differ from the implicit one, which deletes the function -- and is an
-    // error outright with older compilers
-    iter_impl(iter_impl&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
-    iter_impl& operator=(iter_impl&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;

    /*!
    @brief constructor for a given JSON instance
@@ -18,7 +18,6 @@
 #endif

 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -207,10 +206,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {

-// Fix: https://github.com/nlohmann/json/issues/1401
 #if defined(__clang__)
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -225,7 +224,7 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
 #if defined(__clang__)
-    JSON_HEDLEY_DIAGNOSTIC_POP
+    #pragma clang diagnostic pop
 #endif

 }  // namespace std
@@ -17,7 +17,6 @@
 #endif  // JSON_NO_IO
 #include <limits> // max
 #include <numeric> // accumulate
-#include <set> // set
 #include <string> // string
 #include <utility> // move
 #include <vector> // vector
@@ -72,7 +71,7 @@ class json_pointer
                               string_t{},
                               [](const string_t& a, const string_t& b)
        {
-            return detail::concat<string_t>(a, '/', detail::escape(b));
+            return detail::concat(a, '/', detail::escape(b));
        });
    }

@@ -266,7 +265,7 @@ class json_pointer
            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
        }

-        const char* p = s.data();
+        const char* p = s.c_str();
        char* p_end = nullptr; // NOLINT(misc-const-correctness)
        errno = 0; // strtoull doesn't reset errno
        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
@@ -301,35 +300,19 @@ class json_pointer
    }

  private:
-    /*!
-    @brief the reference token sequences that denote arrays
-
-    @ref unflatten collects the pointer prefixes that have a reference token 0
-    among their children; @ref get_and_create creates arrays exactly below
-    those prefixes and objects everywhere else. Deciding this up front keeps
-    the result independent of the order in which the flattened object is
-    iterated, which is unspecified for some object types.
-    */
-    using array_parents_t = std::set<std::vector<string_t>>;
-
    /*!
    @brief create and return a reference to the pointed to value

    @complexity Linear in the number of reference tokens.

-    @throw parse_error.106 if an array index begins with '0'
    @throw parse_error.109 if array index is not a number
    @throw type_error.313 if value cannot be unflattened
    */
    template<typename BasicJsonType>
-    BasicJsonType& get_and_create(BasicJsonType& j, const array_parents_t& array_parents) const
+    BasicJsonType& get_and_create(BasicJsonType& j) const
    {
        auto* result = &j;

-        // the reference tokens that have been consumed so far; used to look up
-        // whether the value to be created below is an array or an object
-        std::vector<string_t> prefix;
-
        // in case no reference tokens exist, return a reference to the JSON value
        // j which will be overwritten by a primitive value
        for (const auto& reference_token : reference_tokens)
@@ -338,11 +321,10 @@ class json_pointer
            {
                case detail::value_t::null:
                {
-                    if (array_parents.find(prefix) != array_parents.end())
+                    if (reference_token == "0")
                    {
-                        // some reference token below this position is 0, so the
-                        // value is an array
-                        result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                        // start a new array if the reference token is 0
+                        result = &result->operator[](0);
                    }
                    else
                    {
@@ -382,8 +364,6 @@ class json_pointer
                default:
                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
            }
-
-            prefix.push_back(reference_token);
        }

        return *result;
@@ -768,20 +748,6 @@ class json_pointer
                        }
                    }

-                    // the reference token consists only of digits at this point (cf. checks
-                    // above); however, its numeric value might not be representable, in which
-                    // case array_index() would throw out_of_range.404/410 -- contains() must
-                    // not throw (see #5395), so such a reference token is treated as "not found"
-                    errno = 0; // strtoull() does not reset errno on success
-                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
-                    const unsigned long long magnitude = std::strtoull(reference_token.c_str(), &p_end, 10); // NOLINT(runtime/int)
-                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE // the value exceeds ULLONG_MAX
-                                             || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
-                    {
-                        // the array index cannot be represented as size_type
-                        return false;
-                    }
-
                    const auto idx = array_index<BasicJsonType>(reference_token);
                    if (idx >= ptr->size())
                    {
@@ -857,8 +823,7 @@ class json_pointer
        {
            // use the text between the beginning of the reference token
            // (start) and the last slash (slash).
-            const auto count = (slash == string_t::npos ? reference_string.size() : slash) - start;
-            auto reference_token = string_t(reference_string.data() + start, count);
+            auto reference_token = reference_string.substr(start, slash - start);

            // check reference tokens are properly escaped
            for (std::size_t pos = reference_token.find_first_of('~');
@@ -974,24 +939,6 @@ class json_pointer

        BasicJsonType result;

-        // collect the pointer prefixes that have a reference token 0 among
-        // their children; the values below them are arrays, all others are
-        // objects (see array_parents_t)
-        array_parents_t array_parents;
-        for (const auto& element : *value.m_data.m_value.object)
-        {
-            json_pointer ptr(element.first);
-            std::vector<string_t> prefix;
-            for (auto& reference_token : ptr.reference_tokens)
-            {
-                if (reference_token == "0")
-                {
-                    array_parents.insert(prefix);
-                }
-                prefix.push_back(std::move(reference_token));
-            }
-        }
-
        // iterate the JSON object values
        for (const auto& element : *value.m_data.m_value.object)
        {
@@ -1004,7 +951,7 @@ class json_pointer
            // that if the JSON pointer is "" (i.e., points to the whole value),
            // function get_and_create returns a reference to the result itself.
            // An assignment will then create a primitive value.
-            json_pointer(element.first).get_and_create(result, array_parents) = element.second;
+            json_pointer(element.first).get_and_create(result) = element.second;
        }

        return result;
@@ -172,18 +172,17 @@ struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
 template<typename T>
 using detect_key_compare = typename T::key_compare;

-// obtains the actual object key comparator: object_t::key_compare if the
-// object type defines it, and default_object_comparator_t otherwise
-//
-// note detected_or_t is used rather than std::conditional, because the latter
-// names both of its type arguments eagerly; object_t::key_compare would then
-// be a hard error for an object type that does not define it
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
 template<typename BasicJsonType>
 struct actual_object_comparator
 {
    using object_t = typename BasicJsonType::object_t;
    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
-    using type = detected_or_t<object_comparator_t, detect_key_compare, object_t>;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
 };

 template<typename BasicJsonType>
@@ -779,22 +778,6 @@ using has_erase_with_key_type = typename std::conditional <
                                std::true_type,
                                std::false_type >::type;

-template<typename ObjectType, typename IteratorType>
-using detect_erase_with_iterator = decltype(std::declval<ObjectType&>().erase(std::declval<IteratorType>()));
-
-// type trait to check if erase(iterator) returns void instead of the following
-// iterator, as the object types that do not compute a successor the caller may
-// not need do
-template<typename ObjectType, typename IteratorType>
-using erase_returns_void = is_detected_exact<void, detect_erase_with_iterator, ObjectType, IteratorType>;
-
-template<typename T>
-using detect_capacity = decltype(std::declval<const T&>().capacity());
-
-// type trait to check if a type has a capacity() member function
-template<typename T>
-struct has_capacity : std::integral_constant<bool, is_detected<detect_capacity, T>::value> {};
-
 // a naive helper to check if a type is an ordered_map (exploits the fact that
 // ordered_map inherits capacity() from std::vector)
 template <typename T>
@@ -261,7 +261,7 @@ class binary_writer

                // step 2: write the string
                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->data()),
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }
@@ -581,7 +581,7 @@ class binary_writer

                // step 2: write the string
                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->data()),
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }
@@ -798,7 +798,7 @@ class binary_writer
                }
                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->data()),
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }
@@ -826,17 +826,7 @@ class binary_writer

                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type

-                    // an optimized array of a valueless type carries no payload, so a
-                    // reader has nothing but the declared count to bound the allocation
-                    // by and refuses an excessive one. Write the unoptimized form for
-                    // those, at one byte per element, so the result can be read back.
-                    // Objects are not affected: every element is preceded by its key.
-                    const bool valueless_type = (first_prefix == 'Z' || first_prefix == 'T' || first_prefix == 'F');
-                    const bool excessive_valueless = valueless_type
-                                                     && j.m_data.m_value.array->size() > detail::max_valueless_container_size;
-
-                    if (same_prefix && !excessive_valueless
-                            && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
                    {
                        prefix_required = false;
                        oa->write_character(to_char_type('$'));
@@ -897,9 +887,7 @@ class binary_writer
                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
                    {
                        oa->write_character(to_char_type(bjdata_draft3 ? 'B' : 'U'));
-                        // the cast is needed for binary types whose value type
-                        // is not an integer (e.g., std::byte)
-                        oa->write_character(to_char_type(static_cast<std::uint8_t>(j.m_data.m_value.binary->data()[i])));
+                        oa->write_character(to_char_type(j.m_data.m_value.binary->data()[i]));
                    }
                }

@@ -960,7 +948,7 @@ class binary_writer
                {
                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
                    oa->write_characters(
-                        reinterpret_cast<const CharType*>(el.first.data()),
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
                        el.first.size());
                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
                }
@@ -1023,11 +1011,8 @@ class binary_writer
    {
        oa->write_character(to_char_type(element_type));
        oa->write_characters(
-            reinterpret_cast<const CharType*>(name.data()),
-            name.size());
-        // the terminating null byte is written explicitly rather than taken
-        // from the buffer, so that string_t::data() need not be null-terminated
-        oa->write_character(to_char_type(0x00));
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
    }

    /*!
@@ -1068,11 +1053,8 @@ class binary_writer

        write_number<std::int32_t>(to_bson_length(value.size() + 1ul), true);
        oa->write_characters(
-            reinterpret_cast<const CharType*>(value.data()),
-            value.size());
-        // the terminating null byte is written explicitly rather than taken
-        // from the buffer, so that string_t::data() need not be null-terminated
-        oa->write_character(to_char_type(0x00));
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
    }

    /*!
@@ -1163,11 +1145,7 @@ class binary_writer

        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
        {
-            // the index is built as a std::string, while calc_bson_element_size
-            // takes a string_t; convert explicitly, as the two are only
-            // implicitly convertible for some string types
-            const auto key = std::to_string(array_index++);
-            return result + calc_bson_element_size(string_t(key.data(), key.size()), el);
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
        });

        return sizeof(std::int32_t) + embedded_document_size + 1ul;
@@ -1194,11 +1172,7 @@ class binary_writer

        for (const auto& el : value)
        {
-            // the index is built as a std::string, while write_bson_element takes
-            // a string_t; convert explicitly, as the two are only implicitly
-            // convertible for some string types
-            const auto key = std::to_string(array_index++);
-            write_bson_element(string_t(key.data(), key.size()), el);
+            write_bson_element(std::to_string(array_index++), el);
        }

        oa->write_character(to_char_type(0x00));
@@ -1673,20 +1647,6 @@ class binary_writer
        return 'D';  // float 64
    }

-    /*!
-    @brief checks whether a JSON number fits into @a TargetType
-    @param[in] el a JSON number of either the signed or unsigned integer kind
-    @return whether @a el's value can be represented by @a TargetType without
-            wrapping, regardless of which of the two kinds it is stored as
-    */
-    template<typename TargetType>
-    static bool bjdata_ndarray_value_in_range(const BasicJsonType& el)
-    {
-        return el.is_number_unsigned()
-               ? value_in_range_of<TargetType>(el.template get<std::uint64_t>())
-               : value_in_range_of<TargetType>(el.template get<std::int64_t>());
-    }
-
    /*!
    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
    */
@@ -1708,15 +1668,6 @@ class binary_writer
        CharType dtype = it->second;

        key = "_ArraySize_";
-        // the dimensions are written verbatim as the header length below, so a
-        // value that is not an array cannot produce a valid one: null emits 'Z'
-        // and an object emits '{', neither of which a reader accepts after '#'.
-        // Such an object is not a valid ndarray and falls back to a plain object.
-        if (!value.at(key).is_array())
-        {
-            return true;
-        }
-
        std::size_t len = (value.at(key).empty() ? 0 : 1);
        for (const auto& el : value.at(key))
        {
@@ -1771,60 +1722,6 @@ class binary_writer
            }
        }

-        // every element is cast to the (possibly narrower) C++ type matching
-        // dtype below; a value that does not fit that type would silently
-        // wrap (integers) or overflow to infinity (the "single" precision
-        // float) instead of being reported, so such an object falls back to
-        // a plain object encoding as well
-        for (const auto& el : value.at(key))
-        {
-            bool in_range = true;
-            switch (dtype)
-            {
-                case 'U':
-                case 'C':
-                case 'B':
-                    in_range = bjdata_ndarray_value_in_range<std::uint8_t>(el);
-                    break;
-                case 'i':
-                    in_range = bjdata_ndarray_value_in_range<std::int8_t>(el);
-                    break;
-                case 'u':
-                    in_range = bjdata_ndarray_value_in_range<std::uint16_t>(el);
-                    break;
-                case 'I':
-                    in_range = bjdata_ndarray_value_in_range<std::int16_t>(el);
-                    break;
-                case 'm':
-                    in_range = bjdata_ndarray_value_in_range<std::uint32_t>(el);
-                    break;
-                case 'l':
-                    in_range = bjdata_ndarray_value_in_range<std::int32_t>(el);
-                    break;
-                case 'M':
-                    in_range = bjdata_ndarray_value_in_range<std::uint64_t>(el);
-                    break;
-                case 'L':
-                    in_range = bjdata_ndarray_value_in_range<std::int64_t>(el);
-                    break;
-                case 'd':
-                {
-                    const auto dval = el.template get<double>();
-                    in_range = !std::isfinite(dval) ||
-                               (dval >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
-                                dval <= static_cast<double>((std::numeric_limits<float>::max)()));
-                    break;
-                }
-                default:
-                    // 'D' (double) already spans the full range of number_float_t
-                    break;
-            }
-            if (!in_range)
-            {
-                return true;
-            }
-        }
-
        oa->write_character('[');
        oa->write_character('$');
        oa->write_character(dtype);
@@ -1944,8 +1841,8 @@ class binary_writer
    void write_compact_float(const number_float_t n, detail::input_format_t format)
    {
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                   static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -1964,7 +1861,7 @@ class binary_writer
            write_number(n);
        }
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#pragma GCC diagnostic pop
 #endif
    }

@@ -8,56 +8,50 @@

 #pragma once

-#include <cstddef> // size_t
-
 #include <nlohmann/detail/abi_macros.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {

+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find the first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find the next occurrence of f
+    {}
+}
+
 /*!
 * @brief string escaping as described in RFC 6901 (Sect. 4)
 * @param[in] s string to escape
 * @return    escaped string
 *
 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
- *
- * The string is rebuilt in a single pass, appending whole runs between the
- * characters that need escaping. Scanning with find_first_of() keeps the
- * common case -- nothing to escape -- as fast as a single search, while
- * repeated replace() calls would move the tail of the string once per
- * escaped character.
 */
 template<typename StringType>
-inline StringType escape(const StringType& s)
+inline StringType escape(StringType s)
 {
-    auto next_special = [&s](std::size_t from)
-    {
-        const auto tilde = s.find_first_of('~', from);
-        const auto slash = s.find_first_of('/', from);
-        return tilde < slash ? tilde : slash; // npos is the largest value
-    };
-
-    auto pos = next_special(0);
-    if (pos == StringType::npos)
-    {
-        return s;
-    }
-
-    StringType result;
-    result.reserve(s.size() + 2);
-
-    std::size_t run = 0;
-    while (pos != StringType::npos)
-    {
-        result.append(s.data() + run, pos - run);
-        result.append(s[pos] == '~' ? "~0" : "~1", 2);
-        run = pos + 1;
-        pos = next_special(run);
-    }
-    result.append(s.data() + run, s.size() - run);
-    return result;
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
 }

 /*!
@@ -66,43 +60,12 @@ inline StringType escape(const StringType& s)
 * @return    unescaped string
 *
 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
- *
- * Rebuilt in a single pass, see @ref escape. A "~" that is followed by
- * neither "0" nor "1" is passed through unchanged; @ref json_pointer rejects
- * such input before it gets here.
 */
 template<typename StringType>
 inline void unescape(StringType& s)
 {
-    auto pos = s.find_first_of('~', 0);
-    if (pos == StringType::npos)
-    {
-        return;
-    }
-
-    StringType result;
-    result.reserve(s.size());
-
-    std::size_t run = 0;
-    while (pos != StringType::npos)
-    {
-        result.append(s.data() + run, pos - run);
-
-        const auto next = pos + 1;
-        if (next < s.size() && (s[next] == '0' || s[next] == '1'))
-        {
-            result.append(s[next] == '0' ? "~" : "/", 1);
-            run = pos + 2;
-        }
-        else
-        {
-            result.append("~", 1);
-            run = pos + 1;
-        }
-        pos = s.find_first_of('~', run);
-    }
-    result.append(s.data() + run, s.size() - run);
-    s = result;
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
 }

 }  // namespace detail
@@ -8,13 +8,10 @@

 #pragma once

-#include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string

 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/macro_scope.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -36,99 +33,5 @@ StringType to_string(std::size_t value)
    return result;
 }

-///////////////////
-// UTF-8 decoding //
-///////////////////
-
-// UTF-8 decoder states used by decode() below
-static constexpr std::uint8_t UTF8_ACCEPT = 0;
-static constexpr std::uint8_t UTF8_REJECT = 1;
-
-/*!
-@brief process a byte of a UTF-8 sequence
-
-This is a single-byte step of a "shift-based" UTF-8 decoder originally
-written by Björn Hoehrmann. See
-http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
-
-This decoder is the single source of truth for UTF-8 validation in this
-library: it is used both by the serializer (to escape and, in strict mode,
-reject ill-formed UTF-8 when dumping a string) and by the binary readers
-(to reject ill-formed UTF-8 in CBOR/MessagePack/BSON/UBJSON text strings at
-decode time; see @ref is_valid_utf8 below).
-
-@param[in,out] state  the current decoder state
-@param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
-@param[in] byte       next byte to decode
-@return               new state
-
-@note Original source: http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-*/
-inline std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
-{
-    static const std::array<std::uint8_t, 400> utf8d =
-    {
-        {
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
-            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
-            8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
-            0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
-            0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
-            0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
-            1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
-            1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
-            1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
-        }
-    };
-
-    JSON_ASSERT(static_cast<std::size_t>(byte) < utf8d.size());
-    const std::uint8_t type = utf8d[byte];
-
-    codep = (state != UTF8_ACCEPT)
-            ? (byte & 0x3fu) | (codep << 6u)
-            : (0xFFu >> type) & (byte);
-
-    const std::size_t index = 256u + (static_cast<std::size_t>(state) * 16u) + static_cast<std::size_t>(type);
-    JSON_ASSERT(index < utf8d.size());
-    state = utf8d[index];
-    return state;
-}
-
-/*!
-@brief check whether a string consists solely of valid UTF-8
-
-Used by the CBOR/MessagePack/BSON/UBJSON binary readers to reject text
-strings that are not valid UTF-8 at decode time (RFC 8949 §3.1 and the
-MessagePack/BSON specifications all require text strings to be UTF-8), so
-that malformed input is caught immediately instead of only surfacing later
-as a type_error.316 when the resulting value is dumped.
-
-@param[in] s  the string to check
-@return whether @a s is valid UTF-8
-*/
-template<typename StringType>
-inline bool is_valid_utf8(const StringType& s) noexcept
-{
-    std::uint8_t state = UTF8_ACCEPT;
-    std::uint32_t codepoint = 0;
-
-    for (std::size_t i = 0; i < s.size(); ++i)
-    {
-        decode(state, codepoint, static_cast<std::uint8_t>(s[i]));
-        if (state == UTF8_REJECT)
-        {
-            return false;
-        }
-    }
-
-    return state == UTF8_ACCEPT;
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -9,12 +9,9 @@
 #pragma once

 #include <array> // array
-#include <cmath> // isnan, ldexp, trunc
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t
-#include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // is_signed

 #include <nlohmann/detail/macro_scope.hpp>
 #if JSON_HAS_THREE_WAY_COMPARISON
@@ -117,67 +114,5 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
 }
 #endif

-
-/*!
-@brief compare an integer with a floating point number without precision loss
-
-Widening the integer to the floating point type loses precision beyond the
-float's mantissa, which makes equality intransitive: both 2^63-2 and 2^63-1
-round to 2^63, so each compares equal to that float while differing from each
-other. Ordering built on that is not a strict weak ordering, so sorting such
-values, or using them as keys in an ordered container, is undefined behavior.
-
-Returns a value to be compared against zero with the original operator, which
-reproduces the exact ordering. A NaN operand is returned as is, so comparing it
-against zero keeps NaN's semantics: false for the relational operators and
-unordered for `<=>`.
-*/
-template<typename IntegerType, typename FloatType>
-FloatType compare_integer_with_float(const IntegerType i, const FloatType f) noexcept
-{
-    const auto ordered = [](int c) noexcept
-    {
-        return static_cast<FloatType>(c);
-    };
-
-    if (std::isnan(f))
-    {
-        return f;
-    }
-
-    // values of IntegerType lie in [-bound, bound) when signed and in
-    // [0, bound) when unsigned; digits excludes the sign bit, so bound is a
-    // power of two that the float represents exactly
-    const FloatType bound = std::ldexp(static_cast<FloatType>(1), std::numeric_limits<IntegerType>::digits);
-    if (f >= bound)
-    {
-        return ordered(-1);
-    }
-    if (std::is_signed<IntegerType>::value ? (f < -bound) : (f < static_cast<FloatType>(0)))
-    {
-        return ordered(1);
-    }
-
-    // f is now within the integer's range, so truncating it is exact
-    const FloatType truncated = std::trunc(f);
-    const auto as_integer = static_cast<IntegerType>(truncated);
-    if (i != as_integer)
-    {
-        return ordered(i < as_integer ? -1 : 1);
-    }
-
-    // the integer parts agree, so any fractional part decides
-    const FloatType fraction = f - truncated;
-    if (fraction > static_cast<FloatType>(0))
-    {
-        return ordered(-1);
-    }
-    if (fraction < static_cast<FloatType>(0))
-    {
-        return ordered(1);
-    }
-    return ordered(0);
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -164,12 +164,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        detail::parser_callback_t<basic_json>cb = nullptr,
        const bool allow_exceptions = true,
        const bool ignore_comments = false,
-        const bool ignore_trailing_commas = false,
-        const bool discard_number_values = false
+        const bool ignore_trailing_commas = false
    )
    {
        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
-               std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas, discard_number_values);
+               std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
    }

  private:
@@ -404,18 +403,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @}

-    // Two template parameter requirements that would otherwise be silently
-    // violated: neither produces a diagnostic of its own, and both corrupt
-    // values rather than failing.
-
-    static_assert(sizeof(typename BinaryType::value_type) == 1,
-                  "BinaryType::value_type must be exactly one byte wide, "
-                  "because the binary readers and writers reinterpret the container's storage as raw bytes");
-
-    static_assert(sizeof(NumberUnsignedType) >= sizeof(NumberIntegerType),
-                  "NumberUnsignedType must be at least as wide as NumberIntegerType, "
-                  "because it has to hold the absolute value of every NumberIntegerType value");
-
  private:

    /// helper for exception-safe object creation
@@ -796,76 +783,21 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return it;
    }

-    /// @brief erase an element from the object and return the following one
-    /// Not every map returns an iterator from erase(iterator): some containers
-    /// (e.g., Abseil's hash maps) return void to avoid computing a successor
-    /// the caller may not need. Compute it before erasing for those.
-    template < typename It, detail::enable_if_t <
-                   !detail::erase_returns_void<object_t, It>::value, int > = 0 >
-    typename object_t::iterator erase_from_object(It pos)
-    {
-        return m_data.m_value.object->erase(pos);
-    }
-
-    template < typename It, detail::enable_if_t <
-                   detail::erase_returns_void<object_t, It>::value, int > = 0 >
-    typename object_t::iterator erase_from_object(It pos)
-    {
-        auto next = std::next(pos);
-        m_data.m_value.object->erase(pos);
-        return next;
-    }
-
-    /// @brief the capacity of the stored array, or unknown_size()
-    /// Only JSON_DIAGNOSTICS uses the value, to detect a reallocation that
-    /// would invalidate the parent pointers. Array types that do not have a
-    /// capacity() member function report unknown_size(), which is treated as
-    /// "the elements may have moved".
-#if JSON_DIAGNOSTICS
-    template < typename A = array_t, detail::enable_if_t < detail::has_capacity<A>::value, int > = 0 >
-    std::size_t array_capacity() const noexcept
-    {
-        return m_data.m_value.array->capacity();
-    }
-
-    template < typename A = array_t, detail::enable_if_t < !detail::has_capacity<A>::value, int > = 0 >
-    std::size_t array_capacity() const noexcept
-    {
-        return detail::unknown_size();
-    }
-#else
-    static constexpr std::size_t array_capacity() noexcept
-    {
-        return detail::unknown_size();
-    }
-#endif
-
-    /// @brief set the parent of a value that has just been added to an array
-    /// @param j the added value
-    /// @param old_capacity the value @ref array_capacity() returned before the
-    ///        insertion
-    reference set_parent_after_array_insert(reference j, std::size_t old_capacity)
+    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
    {
 #if JSON_DIAGNOSTICS
-        // see https://github.com/nlohmann/json/issues/2838
-        JSON_ASSERT(type() == value_t::array);
-        if (JSON_HEDLEY_UNLIKELY(old_capacity == detail::unknown_size()
-                                 || array_capacity() != old_capacity))
+        if (old_capacity != detail::unknown_size())
        {
-            // the capacity has changed, or the array type does not let us tell:
-            // the elements may have moved, so update all parents
-            set_parents();
-            return j;
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
        }
-#else
-        static_cast<void>(old_capacity);
-#endif
-        return set_parent(j);
-    }

-    reference set_parent(reference j)
-    {
-#if JSON_DIAGNOSTICS
        // ordered_json uses a vector internally, so pointers could have
        // been invalidated; see https://github.com/nlohmann/json/issues/2962
 #ifdef JSON_HEDLEY_MSVC_VERSION
@@ -884,6 +816,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        j.m_parent = this;
 #else
        static_cast<void>(j);
+        static_cast<void>(old_capacity);
 #endif
        return j;
    }
@@ -1402,26 +1335,21 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief serialization
    /// @sa https://json.nlohmann.me/api/basic_json/dump/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    string_t dump(const int indent = -1,
                  const char indent_char = ' ',
                  const bool ensure_ascii = false,
                  const error_handler_t error_handler = error_handler_t::strict) const
    {
        string_t result;
-        detail::output_string_adapter<char, string_t> string_adapter(result);
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);

        if (indent >= 0)
        {
-            serializer s(string_adapter, indent_char,
-                         true, ensure_ascii, static_cast<std::size_t>(indent), error_handler);
-            s.dump(*this);
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
        }
        else
        {
-            serializer s(string_adapter, indent_char,
-                         false, ensure_ascii, 0, error_handler);
-            s.dump(*this);
+            s.dump(*this, false, ensure_ascii, 0);
        }

        return result;
@@ -1429,7 +1357,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return the type of the JSON value (explicit)
    /// @sa https://json.nlohmann.me/api/basic_json/type/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr value_t type() const noexcept
    {
        return m_data.m_type;
@@ -1437,7 +1364,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether type is primitive
    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_primitive() const noexcept
    {
        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -1445,7 +1371,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether type is structured
    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_structured() const noexcept
    {
        return is_array() || is_object();
@@ -1453,7 +1378,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is null
    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_null() const noexcept
    {
        return m_data.m_type == value_t::null;
@@ -1461,7 +1385,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is a boolean
    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_boolean() const noexcept
    {
        return m_data.m_type == value_t::boolean;
@@ -1469,7 +1392,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is a number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number() const noexcept
    {
        return is_number_integer() || is_number_float();
@@ -1477,7 +1399,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is an integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_integer() const noexcept
    {
        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -1485,7 +1406,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is an unsigned integer number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_unsigned() const noexcept
    {
        return m_data.m_type == value_t::number_unsigned;
@@ -1493,7 +1413,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is a floating-point number
    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_number_float() const noexcept
    {
        return m_data.m_type == value_t::number_float;
@@ -1501,7 +1420,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is an object
    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_object() const noexcept
    {
        return m_data.m_type == value_t::object;
@@ -1509,7 +1427,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is an array
    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_array() const noexcept
    {
        return m_data.m_type == value_t::array;
@@ -1517,7 +1434,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is a string
    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_string() const noexcept
    {
        return m_data.m_type == value_t::string;
@@ -1525,7 +1441,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is a binary array
    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_binary() const noexcept
    {
        return m_data.m_type == value_t::binary;
@@ -1533,7 +1448,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return whether value is discarded
    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    constexpr bool is_discarded() const noexcept
    {
        return m_data.m_type == value_t::discarded;
@@ -2095,17 +2009,22 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    reference at(size_type idx)
    {
        // at only works for arrays
-        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }
-
-        if (JSON_HEDLEY_UNLIKELY(idx >= m_data.m_value.array->size()))
-        {
-            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
-        }
-
-        return set_parent((*m_data.m_value.array)[idx]);
    }

    /// @brief access specified array element with bounds checking
@@ -2113,17 +2032,22 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    const_reference at(size_type idx) const
    {
        // at only works for arrays
-        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }
-
-        if (JSON_HEDLEY_UNLIKELY(idx >= m_data.m_value.array->size()))
-        {
-            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
-        }
-
-        return (*m_data.m_value.array)[idx];
    }

    /// @brief access specified object element with bounds checking
@@ -2223,13 +2147,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #if JSON_DIAGNOSTICS
                // remember array size & capacity before resizing
                const auto old_size = m_data.m_value.array->size();
-                const auto old_capacity = array_capacity();
+                const auto old_capacity = m_data.m_value.array->capacity();
 #endif
                m_data.m_value.array->resize(idx + 1);

 #if JSON_DIAGNOSTICS
-                if (JSON_HEDLEY_UNLIKELY(old_capacity == detail::unknown_size()
-                                         || array_capacity() != old_capacity))
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
                {
                    // capacity has changed: update all parents
                    set_parents();
@@ -2620,7 +2543,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

            case value_t::object:
            {
-                result.m_it.object_iterator = erase_from_object(pos.m_it.object_iterator);
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
                break;
            }

@@ -2856,7 +2779,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief returns the number of occurrences of a key in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/count/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type count(const typename object_t::key_type& key) const
    {
        // return 0 for all nonobject types
@@ -2867,7 +2789,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/count/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type count(KeyType && key) const
    {
        // return 0 for all nonobject types
@@ -2876,7 +2797,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief check the existence of an element in a JSON object
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(const typename object_t::key_type& key) const
    {
        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -2886,7 +2806,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(KeyType && key) const
    {
        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -2894,14 +2813,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief check the existence of an element in a JSON object given a JSON pointer
    /// @sa https://json.nlohmann.me/api/basic_json/contains/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool contains(const json_pointer& ptr) const
    {
        return ptr.contains(this);
    }

    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
    {
@@ -3057,7 +2974,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief checks whether the container is empty.
    /// @sa https://json.nlohmann.me/api/basic_json/empty/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    bool empty() const noexcept
    {
        switch (m_data.m_type)
@@ -3097,7 +3013,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief returns the number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/size/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type size() const noexcept
    {
        switch (m_data.m_type)
@@ -3137,7 +3052,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief returns the maximum possible number of elements
    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    size_type max_size() const noexcept
    {
        switch (m_data.m_type)
@@ -3259,9 +3173,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        }

        // add the element to the array (move semantics)
-        const auto old_capacity = array_capacity();
+        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->push_back(std::move(val));
-        set_parent_after_array_insert(m_data.m_value.array->back(), old_capacity);
+        set_parent(m_data.m_value.array->back(), old_capacity);
        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
    }

@@ -3292,9 +3206,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        }

        // add the element to the array
-        const auto old_capacity = array_capacity();
+        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->push_back(val);
-        set_parent_after_array_insert(m_data.m_value.array->back(), old_capacity);
+        set_parent(m_data.m_value.array->back(), old_capacity);
    }

    /// @brief add an object to an array
@@ -3380,9 +3294,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        }

        // add the element to the array (perfect forwarding)
-        const auto old_capacity = array_capacity();
+        const auto old_capacity = m_data.m_value.array->capacity();
        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
-        return set_parent_after_array_insert(m_data.m_value.array->back(), old_capacity);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
    }

    /// @brief add an object to an object if key does not exist
@@ -3461,7 +3375,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/insert/
    iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param)
    {
-        return insert(std::move(pos), val);
+        return insert(pos, val);
    }

    /// @brief inserts copies of element into array
@@ -3633,11 +3547,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        std::swap(m_data.m_type, other.m_data.m_type);
        std::swap(m_data.m_value, other.m_data.m_value);

-#if JSON_DIAGNOSTIC_POSITIONS
-        std::swap(start_position, other.start_position);
-        std::swap(end_position, other.end_position);
-#endif
-
        set_parents();
        other.set_parents();
        assert_invariant();
@@ -3664,7 +3573,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.array), other);
-            set_parents();
        }
        else
        {
@@ -3681,7 +3589,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.object), other);
-            set_parents();
        }
        else
        {
@@ -3796,19 +3703,19 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    }                                                                                                    \
    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
    {                                                                                                    \
-        return (detail::compare_integer_with_float(lhs.m_data.m_value.number_integer, rhs.m_data.m_value.number_float)) op (static_cast<number_float_t>(0)); \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
    {                                                                                                    \
-        return (static_cast<number_float_t>(0)) op (detail::compare_integer_with_float(rhs.m_data.m_value.number_integer, lhs.m_data.m_value.number_float)); \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
    {                                                                                                    \
-        return (detail::compare_integer_with_float(lhs.m_data.m_value.number_unsigned, rhs.m_data.m_value.number_float)) op (static_cast<number_float_t>(0)); \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
    {                                                                                                    \
-        return (static_cast<number_float_t>(0)) op (detail::compare_integer_with_float(rhs.m_data.m_value.number_unsigned, lhs.m_data.m_value.number_float)); \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
    {                                                                                                    \
@@ -3863,13 +3770,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    bool operator==(const_reference rhs) const noexcept
    {
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        const_reference lhs = *this;
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#pragma GCC diagnostic pop
 #endif
    }

@@ -3956,12 +3863,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
    {
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
 #ifdef __GNUC__
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#pragma GCC diagnostic pop
 #endif
    }

@@ -4148,10 +4055,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        o.width(0);

        // do the actual serialization
-        detail::output_stream_adapter<char> stream_adapter(o);
-        serializer s(stream_adapter, o.fill(),
-                     pretty_print, false, static_cast<std::size_t>(indentation));
-        s.dump(j);
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
        return o;
    }

@@ -4224,24 +4129,22 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename InputType>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    static bool accept(InputType&& i,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
    }

    /// @brief check if the input is valid JSON (iterator pair, or iterator+sentinel pair for C++20 ranges support)
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
    template<typename IteratorType, typename SentinelType = IteratorType,
             detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    static bool accept(IteratorType first, SentinelType last,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
    }

    JSON_HEDLEY_WARN_UNUSED_RESULT
@@ -4250,7 +4153,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
    {
-        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
+        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
    }

    /// @brief generate SAX events
@@ -4336,7 +4239,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    /// @brief return the type as string
    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
-    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_RETURNS_NON_NULL
    const char* type_name() const noexcept
    {
@@ -4571,11 +4473,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in CBOR format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4591,11 +4490,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4620,11 +4516,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format
@@ -4638,11 +4531,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in MessagePack format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4657,11 +4547,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4684,11 +4571,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format
@@ -4702,11 +4586,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in UBJSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4721,11 +4602,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4748,11 +4626,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format
@@ -4766,11 +4641,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BJData format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4785,11 +4657,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format
@@ -4803,11 +4672,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    /// @brief create a JSON value from an input in BSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4822,11 +4688,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        basic_json result;
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }

    template<typename T>
@@ -4849,11 +4712,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        auto ia = i.get();
        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
-        {
-            result = value_t::discarded;
-        }
-        return result;
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
    }
    /// @}

@@ -5079,36 +4939,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                // note erase performs range check
                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
            }
-            else
-            {
-                // the parent of a "remove" target must be an object or array
-                // (see #5396)
-                JSON_THROW(out_of_range::create(413, detail::concat("cannot remove value: the JSON Patch 'remove' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
-            }
-        };
-
-        // RFC 6902 (section 4.4) forbids "from" from being a proper prefix
-        // of "path" for a "move" operation: a location cannot be moved into
-        // one of its own children. Compares reference tokens (already
-        // unescaped by json_pointer's parser) rather than the raw pointer
-        // strings, since a token may itself contain an escaped '/' or '~'
-        // that would defeat a naive string-prefix comparison. "from" equal
-        // to "path" is *not* a proper prefix and must return false.
-        const auto is_proper_prefix = [](const json_pointer & from, const json_pointer & to)
-        {
-            const auto from_size = from.reference_tokens.size();
-            if (from_size >= to.reference_tokens.size())
-            {
-                return false;
-            }
-            for (std::size_t i = 0; i < from_size; ++i)
-            {
-                if (!(from.reference_tokens[i] == to.reference_tokens[i]))
-                {
-                    return false;
-                }
-            }
-            return true;
        };

        // type check: top level value must be an array
@@ -5186,11 +5016,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    const auto from_path = get_value("move", "from", true).template get<string_t>();
                    json_pointer from_ptr(from_path);

-                    if (JSON_HEDLEY_UNLIKELY(is_proper_prefix(from_ptr, ptr)))
-                    {
-                        JSON_THROW(out_of_range::create(414, detail::concat("cannot move value: 'from' path '", from_path, "' is a proper prefix of 'path' '", path, "'"), &result));
-                    }
-
                    // the "from" location must exist - use at()
                    basic_json const v = result.at(from_ptr);

@@ -5303,17 +5128,19 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                // We now reached the end of at least one array
                // in a second pass, traverse the remaining elements

-                // remove my remaining elements, highest index first; appending
-                // in that order avoids the quadratic reinsertion done before
-                for (std::size_t j = source.size(); j > i; --j)
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
                {
-                    result.push_back(object(
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
                    {
                        {"op", "remove"},
-                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1))}
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(i))}
                    }));
+                    ++i;
                }
-                i = source.size();

                // add other remaining elements
                while (i < target.size())
@@ -17,7 +17,7 @@
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,10 +108,7 @@
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PREDICT_FALSE
-#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC
@@ -2,9 +2,6 @@ cmake_minimum_required(VERSION 3.13...4.0)

 option(JSON_Valgrind    "Execute test suite with Valgrind." OFF)
 option(JSON_FastTests   "Skip expensive/slow tests." OFF)
-option(JSON_TestSimdutf "Build the unit tests against the simdutf UTF-8 validation backend." OFF)
-
-set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_TestSimdutf.")

 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
@@ -128,51 +125,6 @@ json_test_set_test_options(test-unicode4 TEST_PROPERTIES TIMEOUT 3000)
 # add unit tests
 #############################################################################

-# Generate the leak checks for every JSON_HEDLEY_* macro defined in
-# hedley.hpp; tests/src/unit-no-macro-leak.cpp #include-s the result after
-# nlohmann/json.hpp (see issue #5408). Using the shared
-# cmake/scripts/gen_hedley_undef_check.cmake script (also used by `make
-# update_hedley_undef`) instead of a hand-maintained list of macro names
-# means this test can never go stale after a future `make update_hedley`.
-set(hedley_hpp "${PROJECT_SOURCE_DIR}/include/nlohmann/thirdparty/hedley/hedley.hpp")
-set(hedley_undef_check_script "${PROJECT_SOURCE_DIR}/cmake/scripts/gen_hedley_undef_check.cmake")
-set(hedley_undef_checks "${PROJECT_BINARY_DIR}/include/hedley_undef_checks.inc")
-
-# Reconfigure whenever the vendored header or the generator script changes,
-# so a `cmake --build` after `make update_hedley` does not silently keep a
-# stale generated file around.
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
-    "${hedley_hpp}"
-    "${hedley_undef_check_script}")
-
-# Generate once at configure time, so the very first build (before any
-# custom-command build step has run) already has an up-to-date file.
-execute_process(
-    COMMAND ${CMAKE_COMMAND}
-        "-DHEDLEY_HPP=${hedley_hpp}"
-        "-DOUTPUT=${hedley_undef_checks}"
-        -DMODE=checks
-        -P "${hedley_undef_check_script}"
-    RESULT_VARIABLE hedley_undef_check_result
-)
-if(NOT hedley_undef_check_result EQUAL 0)
-    message(FATAL_ERROR "Failed to generate ${hedley_undef_checks}")
-endif()
-
-# Also (re)generate as a build step, so an incremental build after editing
-# hedley.hpp without a full reconfigure still picks up the change.
-add_custom_command(
-    OUTPUT "${hedley_undef_checks}"
-    COMMAND ${CMAKE_COMMAND}
-        "-DHEDLEY_HPP=${hedley_hpp}"
-        "-DOUTPUT=${hedley_undef_checks}"
-        -DMODE=checks
-        -P "${hedley_undef_check_script}"
-    DEPENDS "${hedley_hpp}" "${hedley_undef_check_script}"
-    COMMENT "Generating Hedley undef leak checks"
-    VERBATIM)
-add_custom_target(generate_hedley_undef_checks DEPENDS "${hedley_undef_checks}")
-
 if("${JSON_TestStandards}" STREQUAL "")
    set(test_cxx_standards 11 14 17 20 23)
    unset(test_force)
@@ -197,71 +149,6 @@ if(test_force)
 endif()
 message(STATUS "${msg}")

-#############################################################################
-# optionally validate UTF-8 with simdutf (JSON_USE_SIMDUTF)
-#############################################################################
-
-# The simdutf backend is opt-in and not vendored, so it is fetched here rather
-# than being a checked-in dependency. Everything below hangs off test_main,
-# whose usage requirements every test target inherits; the library target and
-# the installed CMake package are deliberately left untouched.
-if (JSON_TestSimdutf)
-    # simdutf requires C++17, both to compile itself and to be reachable from
-    # the library, which keeps its scalar validator below that. Find a tested
-    # standard that satisfies it.
-    set(simdutf_standard "")
-    foreach(cxx_standard ${test_cxx_standards})
-        if(NOT cxx_standard LESS 17 AND compiler_supports_cpp_${cxx_standard})
-            set(simdutf_standard ${cxx_standard})
-            break()
-        endif()
-    endforeach()
-
-    if("${simdutf_standard}" STREQUAL "")
-        # Building simdutf would fail outright without a C++17 compiler, and
-        # even with one it would go unused if no C++17-or-later standard is
-        # tested. Say so and fall back to the scalar validator rather than
-        # failing the build.
-        if(NOT compiler_supports_cpp_17)
-            set(simdutf_reason "the compiler does not support C++17")
-        else()
-            set(simdutf_reason "no tested standard is C++17 or later (testing ${msg_standards})")
-        endif()
-        message(WARNING
-            "JSON_TestSimdutf is enabled, but ${simdutf_reason}. simdutf requires C++17, so it "
-            "is not fetched and JSON_USE_SIMDUTF is not defined: the tests run against the "
-            "built-in scalar UTF-8 validator instead. Set JSON_TestStandards to include 17 or "
-            "later, or build with a compiler that supports C++17.")
-    else()
-        if (CMAKE_VERSION VERSION_LESS 3.18)
-            message(FATAL_ERROR "JSON_TestSimdutf requires CMake 3.18 or later (simdutf's minimum).")
-        endif()
-
-        include(FetchContent)
-
-        # simdutf builds its tests and tools by default, and its tests pull
-        # further dependencies of their own; only the library is needed here
-        set(SIMDUTF_TESTS OFF CACHE BOOL "" FORCE)
-        set(SIMDUTF_TOOLS OFF CACHE BOOL "" FORCE)
-        set(SIMDUTF_BENCHMARKS OFF CACHE BOOL "" FORCE)
-        set(SIMDUTF_ICONV OFF CACHE BOOL "" FORCE)
-
-        FetchContent_Declare(simdutf
-            URL https://github.com/simdutf/simdutf/archive/refs/tags/v${JSON_SIMDUTF_VERSION}.tar.gz
-            DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-        )
-        FetchContent_MakeAvailable(simdutf)
-
-        target_compile_definitions(test_main PUBLIC JSON_USE_SIMDUTF)
-        target_link_libraries(test_main PUBLIC simdutf::simdutf)
-
-        # simdutf.h requires C++17; below that the library keeps its scalar
-        # validator, so any C++11/14 test targets exercise the fallback and the
-        # C++17-and-later ones exercise simdutf. Both must agree.
-        message(STATUS "UTF-8 validation delegated to simdutf ${JSON_SIMDUTF_VERSION} for C++17 and later (JSON_USE_SIMDUTF)")
-    endif()
-endif()
-
 # *DO* use json_test_set_test_options() above this line

 json_test_should_build_32bit_test(json_32bit_test json_32bit_test_only "${JSON_32bitTest}")
@@ -276,14 +163,6 @@ foreach(file ${files})
    json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
 endforeach()

-# tests/src/unit-no-macro-leak.cpp #include-s the generated leak-check file,
-# so its test targets must be built after generate_hedley_undef_checks.
-foreach(cxx_standard ${test_cxx_standards})
-    if(TARGET test-no-macro-leak_cpp${cxx_standard})
-        add_dependencies(test-no-macro-leak_cpp${cxx_standard} generate_hedley_undef_checks)
-    endif()
-endforeach()
-
 if(json_32bit_test_only)
    # Skip all other tests in this file
    return()
@@ -298,24 +177,6 @@ json_test_add_test_for(src/unit-comparison.cpp
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )

-# test the parser again with JSON_DIAGNOSTIC_POSITIONS enabled
-json_test_set_test_options(test-class_parser_diagnostic_positions
-    COMPILE_DEFINITIONS JSON_DIAGNOSTIC_POSITIONS=1
-)
-json_test_add_test_for(src/unit-class_parser.cpp
-    NAME test-class_parser_diagnostic_positions
-    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-)
-
-# test diagnostic positions again without regular diagnostics (JSON pointer paths)
-json_test_set_test_options(test-diagnostic-positions_only
-    COMPILE_DEFINITIONS JSON_DIAGNOSTICS=0
-)
-json_test_add_test_for(src/unit-diagnostic-positions.cpp
-    NAME test-diagnostic-positions_only
-    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-)
-
 # *DO NOT* use json_test_set_test_options() below this line

 #############################################################################
@@ -81,44 +81,6 @@ BENCHMARK_CAPTURE(ParseString, signed_ints,       TEST_DATA_DIRECTORY "/regressi
 BENCHMARK_CAPTURE(ParseString, unsigned_ints,     TEST_DATA_DIRECTORY "/regression/unsigned_ints.json");
 BENCHMARK_CAPTURE(ParseString, small_signed_ints, TEST_DATA_DIRECTORY "/regression/small_signed_ints.json");

-//////////////////////////////////////////////////////////////////////////////
-// parse pretty-printed JSON from string
-//
-// Every file in the corpus above is minified or only lightly spaced, so none of
-// them exercise the lexer's whitespace handling. Real-world JSON is frequently
-// indented - configuration files, pretty-printed API responses, anything kept
-// under version control - where insignificant whitespace can outweigh the data.
-// Re-serializing a document with an indentation and parsing that keeps the
-// content identical to the ParseString row above, so the pair isolates the cost
-// of the whitespace alone.
-//////////////////////////////////////////////////////////////////////////////
-
-static void ParseIndented(benchmark::State& state, const char* filename, int indent)
-{
-    std::ifstream f(filename);
-    std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
-    const std::string indented = json::parse(str).dump(indent);
-
-    while (state.KeepRunning())
-    {
-        state.PauseTiming();
-        auto* j = new json();
-        state.ResumeTiming();
-
-        *j = json::parse(indented);
-
-        state.PauseTiming();
-        delete j;
-        state.ResumeTiming();
-    }
-
-    state.SetBytesProcessed(state.iterations() * indented.size());
-}
-BENCHMARK_CAPTURE(ParseIndented, jeopardy / 4,     TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json",                 4);
-BENCHMARK_CAPTURE(ParseIndented, canada / 4,       TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json",       4);
-BENCHMARK_CAPTURE(ParseIndented, citm_catalog / 4, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", 4);
-BENCHMARK_CAPTURE(ParseIndented, twitter / 4,      TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json",      4);
-
 //////////////////////////////////////////////////////////////////////////////
 // serialize JSON
 //////////////////////////////////////////////////////////////////////////////
@@ -252,323 +214,4 @@ static void BinaryToCbor(benchmark::State& state)
 }
 BENCHMARK(BinaryToCbor)->RangeMultiplier(2)->Range(8, 8 << 12);

-//////////////////////////////////////////////////////////////////////////////
-// parse binary formats
-//////////////////////////////////////////////////////////////////////////////
-
-// Only MessagePack had a read benchmark (FromMsgpack above, left untouched so
-// its numbers stay comparable across releases). The benchmarks below cover the
-// other formats, and read from a contiguous buffer as well as from a FILE*:
-// most callers pass a container, and the two adapters compile to different
-// code. The test data repository ships JSON only, so the input for each is
-// derived at setup time by serializing a parsed test file.
-
-/// binary format to benchmark; the _optimized variants add UBJSON/BJData size
-/// and type annotations, which the readers handle in a separate code path
-enum class binary_format
-{
-    cbor,
-    msgpack,
-    ubjson,
-    ubjson_optimized,
-    bjdata,
-    bjdata_optimized,
-    bson
-};
-
-static std::vector<std::uint8_t> to_binary(const json& j, const binary_format format)
-{
-    switch (format)
-    {
-        case binary_format::cbor:
-            return json::to_cbor(j);
-        case binary_format::msgpack:
-            return json::to_msgpack(j);
-        case binary_format::ubjson:
-            return json::to_ubjson(j);
-        case binary_format::ubjson_optimized:
-            return json::to_ubjson(j, true, true);
-        case binary_format::bjdata:
-            return json::to_bjdata(j);
-        case binary_format::bjdata_optimized:
-            return json::to_bjdata(j, true, true);
-        case binary_format::bson:
-        default:
-            return json::to_bson(j);
-    }
-}
-
-static json from_binary(const std::vector<std::uint8_t>& bytes, const binary_format format)
-{
-    switch (format)
-    {
-        case binary_format::cbor:
-            return json::from_cbor(bytes);
-        case binary_format::msgpack:
-            return json::from_msgpack(bytes);
-        case binary_format::ubjson:
-        case binary_format::ubjson_optimized:
-            return json::from_ubjson(bytes);
-        case binary_format::bjdata:
-        case binary_format::bjdata_optimized:
-            return json::from_bjdata(bytes);
-        case binary_format::bson:
-        default:
-            return json::from_bson(bytes);
-    }
-}
-
-static json from_binary(std::FILE* file, const binary_format format)
-{
-    switch (format)
-    {
-        case binary_format::cbor:
-            return json::from_cbor(file);
-        case binary_format::msgpack:
-            return json::from_msgpack(file);
-        case binary_format::ubjson:
-        case binary_format::ubjson_optimized:
-            return json::from_ubjson(file);
-        case binary_format::bjdata:
-        case binary_format::bjdata_optimized:
-            return json::from_bjdata(file);
-        case binary_format::bson:
-        default:
-            return json::from_bson(file);
-    }
-}
-
-/*!
-@brief serialize a parsed test file to @a format
-
-Returns an empty vector and marks the benchmark as skipped if the file cannot
-be represented in the format, rather than letting the exception escape: BSON
-requires an object at the top level, and several test files are arrays.
-*/
-static std::vector<std::uint8_t> binary_input(benchmark::State& state, const char* filename, const binary_format format)
-{
-    std::ifstream f(filename);
-    std::string const str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
-    const json j = json::parse(str);
-
-    if (format == binary_format::bson && !j.is_object())
-    {
-        state.SkipWithError("BSON requires an object at the top level");
-        return {};
-    }
-
-    return to_binary(j, format);
-}
-
-static void FromBinaryBuffer(benchmark::State& state, const char* filename, const binary_format format)
-{
-    const std::vector<std::uint8_t> bytes = binary_input(state, filename, format);
-    if (bytes.empty())
-    {
-        return;
-    }
-
-    for (auto _ : state)
-    {
-        // the value is destroyed outside the timed section, because destroying
-        // a large DOM is not what this benchmark measures
-        state.PauseTiming();
-        auto* j = new json();
-        state.ResumeTiming();
-
-        *j = from_binary(bytes, format);
-
-        state.PauseTiming();
-        delete j;
-        state.ResumeTiming();
-    }
-
-    state.SetBytesProcessed(state.iterations() * bytes.size());
-}
-
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / jeopardy, TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / floats, TEST_DATA_DIRECTORY "/regression/floats.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, cbor / signed_ints, TEST_DATA_DIRECTORY "/regression/signed_ints.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryBuffer, msgpack / jeopardy, TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json", binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryBuffer, msgpack / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryBuffer, msgpack / citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryBuffer, msgpack / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson / jeopardy, TEST_DATA_DIRECTORY "/jeopardy/jeopardy.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson / citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson_optimized / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::ubjson_optimized);
-BENCHMARK_CAPTURE(FromBinaryBuffer, ubjson_optimized / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::ubjson_optimized);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bjdata / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::bjdata);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bjdata / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::bjdata);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bjdata_optimized / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::bjdata_optimized);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bjdata_optimized / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::bjdata_optimized);
-// BSON requires an object at the top level, so the array-rooted test files
-// (jeopardy and the regression files) cannot be captured here
-BENCHMARK_CAPTURE(FromBinaryBuffer, bson / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::bson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bson / citm_catalog, TEST_DATA_DIRECTORY "/nativejson-benchmark/citm_catalog.json", binary_format::bson);
-BENCHMARK_CAPTURE(FromBinaryBuffer, bson / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::bson);
-
-static void FromBinaryFile(benchmark::State& state, const char* filename, const binary_format format)
-{
-    const std::vector<std::uint8_t> bytes = binary_input(state, filename, format);
-    if (bytes.empty())
-    {
-        return;
-    }
-
-    const char* tmp = "benchmark_input.bin";
-    std::ofstream o(tmp, std::ios::binary);
-    o.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
-    o.flush();
-    o.close();
-
-    for (auto _ : state)
-    {
-        state.PauseTiming();
-        auto* j = new json();
-        auto* file = std::fopen(tmp, "rb");
-        state.ResumeTiming();
-
-        *j = from_binary(file, format);
-
-        state.PauseTiming();
-        std::fclose(file);
-        delete j;
-        state.ResumeTiming();
-    }
-
-    state.SetBytesProcessed(state.iterations() * bytes.size());
-}
-
-BENCHMARK_CAPTURE(FromBinaryFile, cbor / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryFile, cbor / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryFile, ubjson / canada, TEST_DATA_DIRECTORY "/nativejson-benchmark/canada.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryFile, ubjson / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryFile, bjdata / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::bjdata);
-BENCHMARK_CAPTURE(FromBinaryFile, bson / twitter, TEST_DATA_DIRECTORY "/nativejson-benchmark/twitter.json", binary_format::bson);
-
-//////////////////////////////////////////////////////////////////////////////
-// parse binary formats: value shapes
-//////////////////////////////////////////////////////////////////////////////
-
-// The test files above are wide and shallow, but the readers' cost is per
-// container, so these cover the shapes that stress the container handling
-// itself. Every shape is wrapped in an object so that BSON, which requires an
-// object at the top level, measures the same value as the other formats.
-
-/// deeply nested arrays: one container per level, no other work
-static json make_nested()
-{
-    json nested = json::array();
-    json* p = &nested;
-    for (std::size_t i = 1; i < 1000; ++i)
-    {
-        p->push_back(json::array());
-        p = &p->operator[](0);
-    }
-
-    json j = json::object();
-    j["data"] = std::move(nested);
-    return j;
-}
-
-/// many sibling containers: maximum container churn, minimum nesting
-static json make_containers()
-{
-    json data = json::array();
-    for (std::size_t i = 0; i < 100000; ++i)
-    {
-        data.push_back(json::array({1, 2}));
-    }
-
-    json j = json::object();
-    j["data"] = std::move(data);
-    return j;
-}
-
-/// one flat array of numbers: the scalar decoding path, which must not move
-static json make_scalars()
-{
-    json data = json::array();
-    for (std::size_t i = 0; i < 1000000; ++i)
-    {
-        data.push_back(i);
-    }
-
-    json j = json::object();
-    j["data"] = std::move(data);
-    return j;
-}
-
-static void FromBinaryShape(benchmark::State& state, json (*build)(), const binary_format format)
-{
-    const std::vector<std::uint8_t> bytes = to_binary(build(), format);
-
-    for (auto _ : state)
-    {
-        state.PauseTiming();
-        auto* j = new json();
-        state.ResumeTiming();
-
-        *j = from_binary(bytes, format);
-
-        state.PauseTiming();
-        delete j;
-        state.ResumeTiming();
-    }
-
-    state.SetBytesProcessed(state.iterations() * bytes.size());
-}
-
-BENCHMARK_CAPTURE(FromBinaryShape, nested / cbor, make_nested, binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryShape, nested / msgpack, make_nested, binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryShape, nested / ubjson, make_nested, binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryShape, nested / bjdata, make_nested, binary_format::bjdata);
-BENCHMARK_CAPTURE(FromBinaryShape, nested / bson, make_nested, binary_format::bson);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / cbor, make_containers, binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / msgpack, make_containers, binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / ubjson, make_containers, binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / ubjson_optimized, make_containers, binary_format::ubjson_optimized);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / bjdata, make_containers, binary_format::bjdata);
-BENCHMARK_CAPTURE(FromBinaryShape, containers / bson, make_containers, binary_format::bson);
-// BSON names every array element, so a large array measures key generation
-// rather than scalar decoding and is left out here
-BENCHMARK_CAPTURE(FromBinaryShape, scalars / cbor, make_scalars, binary_format::cbor);
-BENCHMARK_CAPTURE(FromBinaryShape, scalars / msgpack, make_scalars, binary_format::msgpack);
-BENCHMARK_CAPTURE(FromBinaryShape, scalars / ubjson, make_scalars, binary_format::ubjson);
-BENCHMARK_CAPTURE(FromBinaryShape, scalars / bjdata, make_scalars, binary_format::bjdata);
-
-/*!
-@brief parse an indefinite-length CBOR string
-
-The writer never emits this form, so the input is assembled by hand: 0x7F
-opens the string, each chunk is a one-character string, and 0xFF closes it.
-*/
-static void FromCborChunkedString(benchmark::State& state, const std::size_t chunks)
-{
-    std::vector<std::uint8_t> bytes;
-    bytes.reserve(2 * chunks + 2);
-    bytes.push_back(0x7F);
-    for (std::size_t i = 0; i < chunks; ++i)
-    {
-        bytes.push_back(0x61); // string of length 1
-        bytes.push_back(0x61); // 'a'
-    }
-    bytes.push_back(0xFF);
-
-    for (auto _ : state)
-    {
-        json j = json::from_cbor(bytes);
-        benchmark::DoNotOptimize(j);
-    }
-
-    state.SetBytesProcessed(state.iterations() * bytes.size());
-}
-
-BENCHMARK_CAPTURE(FromCborChunkedString, 10000 chunks, 10000);
-
 BENCHMARK_MAIN();
@@ -15,15 +15,6 @@
 namespace utils
 {

-// Some tests intentionally discard the [[nodiscard]]/JSON_HEDLEY_WARN_UNUSED_RESULT
-// return value of a call they only make to exercise its side effects (e.g. checking
-// that it does not throw). A plain (void) cast on the call expression does not
-// suppress GCC's warning for functions using the GNU __attribute__((warn_unused_result))
-// form (as opposed to the C++17 [[nodiscard]] attribute) -- passing the value into an
-// ordinary function call does.
-template<typename T>
-inline void ignore_return_value(T&& /*unused*/) noexcept {}
-
 inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
 {
    std::ifstream file(filename, std::ios::binary);
@@ -11,10 +11,8 @@

 #include <nlohmann/json.hpp>

-#include <cstdint>
 #include <string>
 #include <utility>
-#include <vector>

 /* forward declarations */
 class alt_string;
@@ -24,10 +22,6 @@ void int_to_string(alt_string& target, std::size_t value); // NOLINT(misc-use-in
 /*
 * This is virtually a string class.
 * It covers std::string under the hood.
- *
- * It deliberately does not provide c_str(), back(), find(str, pos), replace(),
- * or substr(): the library must not rely on them. Do not add members here
- * without checking that the library actually needs them.
 */
 class alt_string
 {
@@ -112,6 +106,11 @@ class alt_string
        return str_impl < op.str_impl;
    }

+    const char* c_str() const
+    {
+        return str_impl.c_str();
+    }
+
    char& operator[](std::size_t index)
    {
        return str_impl[index];
@@ -122,6 +121,16 @@ class alt_string
        return str_impl[index];
    }

+    char& back()
+    {
+        return str_impl.back();
+    }
+
+    const char& back() const
+    {
+        return str_impl.back();
+    }
+
    void clear()
    {
        str_impl.clear();
@@ -137,11 +146,28 @@ class alt_string
        return str_impl.empty();
    }

+    std::size_t find(const alt_string& str, std::size_t pos = 0) const
+    {
+        return str_impl.find(str.str_impl, pos);
+    }
+
    std::size_t find_first_of(char c, std::size_t pos = 0) const
    {
        return str_impl.find_first_of(c, pos);
    }

+    alt_string substr(std::size_t pos = 0, std::size_t count = npos) const
+    {
+        const std::string s = str_impl.substr(pos, count);
+        return {s.data(), s.size()};
+    }
+
+    alt_string& replace(std::size_t pos, std::size_t count, const alt_string& str)
+    {
+        str_impl.replace(pos, count, str.str_impl);
+        return *this;
+    }
+
    void reserve( std::size_t new_cap = 0 )
    {
        str_impl.reserve(new_cap);
@@ -176,31 +202,6 @@ bool operator<(const char* op1, const alt_string& op2) noexcept

 TEST_CASE("alternative string type")
 {
-    SECTION("binary formats")
-    {
-        alt_json doc;
-        doc["pi"] = 3.141;
-        doc["happy"] = true;
-        doc["list"] = {1, 2, 3};
-
-        CHECK(alt_json::from_cbor(alt_json::to_cbor(doc)) == doc);
-        CHECK(alt_json::from_msgpack(alt_json::to_msgpack(doc)) == doc);
-        // BSON is not covered: it additionally needs string_t::find(value_type),
-        // which alt_string does not provide
-        CHECK(alt_json::from_ubjson(alt_json::to_ubjson(doc)) == doc);
-
-        // a UBJSON high-precision number is parsed into a std::string that the
-        // reader has to hand to the SAX interface as an alt_string
-        const std::vector<uint8_t> high_precision =
-        {
-            'H', 'i', 0x16, '3', '.', '1', '4', '1', '5', '9', '2', '6', '5', '3',
-            '5', '8', '9', '7', '9', '3', '2', '3', '8', '4', '6'
-        };
-        const auto number = alt_json::from_ubjson(high_precision);
-        CHECK(number.is_number_float());
-        CHECK(number.get<double>() == doctest::Approx(3.14159265358979323846));
-    }
-
    SECTION("dump")
    {
        {
@@ -331,15 +332,6 @@ TEST_CASE("alternative string type")

        CHECK(j.at(alt_json::json_pointer("/foo/0")) == j["foo"][0]);
        CHECK(j.at(alt_json::json_pointer("/foo/1")) == j["foo"][1]);
-
-        // RFC 6901 escaping works without string_t::find(str, pos), replace(),
-        // and substr()
-        auto j2 = alt_json::parse(R"({"a/b": 1, "m~n": 2, "~/~~//": 3})");
-        CHECK(j2.at(alt_json::json_pointer("/a~1b")) == 1);
-        CHECK(j2.at(alt_json::json_pointer("/m~0n")) == 2);
-        CHECK(j2.at(alt_json::json_pointer("/~0~1~0~0~1~1")) == 3);
-        CHECK(alt_json::json_pointer("/~0~1~0~0~1~1").to_string() == alt_string("/~0~1~0~0~1~1"));
-        CHECK(j2.flatten().unflatten() == j2);
    }

    SECTION("patch")
@@ -2751,78 +2751,6 @@ TEST_CASE("BJData")
                CHECK(json::to_bjdata(j_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, 'i', 3, ']', 1, 2, 3, 4, 5, 6}));
                CHECK(json::from_bjdata(json::to_bjdata(j_ok), true, true) == j_ok);
            }
-
-            SECTION("ndarray whose _ArraySize_ is not an array stays as object")
-            {
-                // the shape is written verbatim as the header length, so a
-                // value that is not an array cannot produce a valid one: null
-                // would emit 'Z' and an object '{', neither of which a reader
-                // accepts after '#'. Both have to stay plain objects.
-                json const j_null = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", nullptr}, {"_ArrayData_", json::array()}});
-                const auto out_null = json::to_bjdata(j_null);
-                CHECK(out_null.at(0) == '{');
-                CHECK(json::from_bjdata(out_null) == j_null);
-
-                // an object shape passes the per-entry check by iterating its
-                // values rather than dimensions, so it needs rejecting too
-                json const j_obj = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {{"a", 1}}}, {"_ArrayData_", {1}}});
-                const auto out_obj = json::to_bjdata(j_obj);
-                CHECK(out_obj.at(0) == '{');
-                CHECK(json::from_bjdata(out_obj) == j_obj);
-
-                // a scalar shape is not a dimension list either
-                json const j_num = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", 1}, {"_ArrayData_", {1}}});
-                const auto out_num = json::to_bjdata(j_num);
-                CHECK(out_num.at(0) == '{');
-                CHECK(json::from_bjdata(out_num) == j_num);
-            }
-
-            SECTION("ndarray with out-of-range _ArrayData_ elements stays as object")
-            {
-                // each element is cast to the (possibly narrower) C++ type
-                // named by _ArrayType_ before being written; a value that
-                // does not fit that type would silently wrap instead of
-                // being reported, so such an object falls back to a plain
-                // object encoding that still round-trips (see GitHub issue #5403)
-
-                // an unsigned element that does not fit uint8
-                json const j_uint8 = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 256}}});
-                const auto out_uint8 = json::to_bjdata(j_uint8);
-                CHECK(out_uint8.at(0) == '{');
-                CHECK(json::from_bjdata(out_uint8) == j_uint8);
-
-                // a signed element that does not fit int8
-                json const j_int8 = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 200}}});
-                const auto out_int8 = json::to_bjdata(j_int8);
-                CHECK(out_int8.at(0) == '{');
-                CHECK(json::from_bjdata(out_int8) == j_int8);
-
-                // a negative element is likewise out of range for an
-                // unsigned _ArrayType_
-                json const j_uint16_neg = json({{"_ArrayType_", "uint16"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, -1}}});
-                const auto out_uint16_neg = json::to_bjdata(j_uint16_neg);
-                CHECK(out_uint16_neg.at(0) == '{');
-                CHECK(json::from_bjdata(out_uint16_neg) == j_uint16_neg);
-
-                // a double element that overflows to infinity when narrowed
-                // to the "single" (float) precision named by _ArrayType_
-                json const j_single = json({{"_ArrayType_", "single"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1.5, 1e40}}});
-                const auto out_single = json::to_bjdata(j_single);
-                CHECK(out_single.at(0) == '{');
-                CHECK(json::from_bjdata(out_single) == j_single);
-
-                // in-range boundary values still use the compact ndarray encoding
-                json const j_uint8_ok = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {0, 255}}});
-                CHECK(json::to_bjdata(j_uint8_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, ']', 0, 255}));
-
-                json const j_int8_ok = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {-128, 127}}});
-                CHECK(json::to_bjdata(j_int8_ok) == std::vector<uint8_t>({'[', '$', 'i', '#', '[', 'i', 2, ']', 0x80, 0x7F}));
-
-                json const j_single_ok = json({{"_ArrayType_", "single"}, {"_ArraySize_", {1}}, {"_ArrayData_", {1.5}}});
-                const auto out_single_ok = json::to_bjdata(j_single_ok);
-                CHECK(out_single_ok.at(0) == '[');
-                CHECK(json::from_bjdata(out_single_ok) == json({1.5f}));
-            }
        }
    }

@@ -2892,23 +2820,6 @@ TEST_CASE("BJData")
                CHECK(json::from_bjdata(vl, true, false).is_discarded());
            }

-            SECTION("invalid UTF-8 in string (see #5529)")
-            {
-                // a BJData string of length 2 whose bytes are not valid
-                // UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
-                // rejected at decode time, matching every other kind of
-                // malformed binary input, rather than only failing later
-                // when the resulting value is dumped
-                std::vector<uint8_t> const v = {'S', 'i', 0x02, 0xc0, 0xae};
-                json _;
-                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(v), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing BJData string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
-                CHECK(json::from_bjdata(v, true, false).is_discarded());
-
-                // valid UTF-8 must still round-trip
-                const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
-                CHECK(json::from_bjdata(json::to_bjdata(j)) == j);
-            }
-
            SECTION("parse bjdata markers in ubjson")
            {
                // create a single-character string for all number types
@@ -3352,10 +3263,8 @@ TEST_CASE("BJData")
            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR1), "[json.exception.parse_error.113] parse error at byte 6: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vR1, true, false).is_discarded());

-            // a dimension vector that opens another one is rejected where the
-            // nested '[' is read, rather than after it has been descended into
            std::vector<uint8_t> const vR2 = {'[', '$', 'i', '#', '[', '#', '[', 'i', 1, ']', ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 7: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 11: syntax error while parsing BJData size: expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x5D", json::parse_error&);
            CHECK(json::from_bjdata(vR2, true, false).is_discarded());

            std::vector<uint8_t> const vR3 = {'[', '#', '[', 'i', '2', 'i', 2, ']'};
@@ -3363,7 +3272,7 @@ TEST_CASE("BJData")
            CHECK(json::from_bjdata(vR3, true, false).is_discarded());

            std::vector<uint8_t> const vR4 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', 1, ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.110] parse error at byte 14: syntax error while parsing BJData number: unexpected end of input", json::parse_error&);
            CHECK(json::from_bjdata(vR4, true, false).is_discarded());

            std::vector<uint8_t> const vR5 = {'[', '$', 'i', '#', '[', '[', '[', ']', ']', ']'};
@@ -3371,25 +3280,12 @@ TEST_CASE("BJData")
            CHECK(json::from_bjdata(vR5, true, false).is_discarded());

            std::vector<uint8_t> const vR6 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.112] parse error at byte 14: syntax error while parsing BJData size: ndarray can not be recursive", json::parse_error&);
            CHECK(json::from_bjdata(vR6, true, false).is_discarded());

            std::vector<uint8_t> const vH = {'[', 'H', '[', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vH), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
            CHECK(json::from_bjdata(vH, true, false).is_discarded());
-
-            // Every "#[" of this chain used to open another dimension vector
-            // and cost several stack frames before anything was rejected, so a
-            // long enough chain crashed the process (see #5104). The nested
-            // vector is refused where it is read, so the length is irrelevant.
-            std::vector<uint8_t> vRdeep = {'['};
-            for (std::size_t i = 0; i < 100000; ++i)
-            {
-                vRdeep.push_back('#');
-                vRdeep.push_back('[');
-            }
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vRdeep), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
-            CHECK(json::from_bjdata(vRdeep, true, false).is_discarded());
        }

        SECTION("objects")
@@ -3568,111 +3464,6 @@ TEST_CASE("BJData")
    }
 }

-TEST_CASE("issue #5405 - array reserve for definite-length BJData arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // optimized form [$type#count: type 'i' (int8), count as a four-byte
-        // little-endian 'l' (int32) of 0x7FFFFFFF (2147483647), but no
-        // element data at all. max_size() for a std::vector is far larger
-        // than this count, so it does not reject the header outright; the
-        // (capped) reservation must not attempt to allocate space for
-        // billions of elements before the missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {'[', '$', 'i', '#', 'l', 0xFF, 0xFF, 0xFF, 0x7F};
-        // On a platform where std::vector<json>::max_size() is smaller than
-        // the claimed count (e.g. 32-bit, where max_size() is bounded by a
-        // 32-bit SIZE_MAX divided by sizeof(json)), the SAX consumer's own
-        // check rejects the header outright (out_of_range.408, with the
-        // claimed count in the message) instead of accepting it and only
-        // finding it short of data once the (capped) reservation looks for
-        // element bytes that were never provided (parse_error.110). Either
-        // is an acceptable, bounded rejection of the hostile header -- the
-        // property under test is that no path attempts to allocate space
-        // for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_bjdata(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing BJData number: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive array size") != std::string::npos);
-        }
-        CHECK(threw);
-
-        // json_sax_dom_parser::start_array()'s max_size() check (unlike the
-        // scanner's own parse_error path) throws unconditionally via
-        // JSON_THROW rather than going through sax->parse_error(), so it is
-        // not gated by allow_exceptions=false on a platform where this
-        // header hits that check (e.g. 32-bit, see above) -- allow either
-        // a discarded result or the same out_of_range it throws with
-        // exceptions enabled.
-        try
-        {
-            CHECK(json::from_bjdata(input, true, false).is_discarded());
-        }
-        catch (const json::out_of_range& e)
-        {
-            CHECK(e.id == 408);
-        }
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            // exercise both the plain and the optimized [$type#count encoding
-            const auto packed_plain = json::to_bjdata(j);
-            CHECK(json::from_bjdata(packed_plain) == j);
-
-            const auto packed_optimized = json::to_bjdata(j, true, true);
-            CHECK(json::from_bjdata(packed_optimized) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_bjdata(j, true, true);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::bjdata));
-    }
-}
-
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
    SECTION("Null Value")
@@ -38,54 +38,6 @@ class huge_binary_t : public std::vector<std::uint8_t>
 using huge_binary_json = nlohmann::basic_json <
                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
                         double, std::allocator, nlohmann::adl_serializer, huge_binary_t, void >;
-
-// a string type that can be made to report a size beyond INT32_MAX without
-// allocating that much memory, so BSON length overflow can be tested for
-// strings and (embedded) documents as well, following the same idea as
-// huge_binary_t.
-//
-// Unlike huge_binary_t (which is only ever used as the BSON *value* type),
-// this type doubles as basic_json's StringType and is therefore also used
-// for *object keys* (e.g. "s" or "nested" below). Only the designated test
-// value is meant to lie about its size - if every huge_string_t (including
-// keys) reported a huge size, the running totals computed while walking the
-// BSON document (see calc_bson_object_size & friends in binary_writer.hpp)
-// would need more than 32 bits, and on platforms where std::size_t is only
-// 32 bits wide that arithmetic would silently wrap around, producing wrong
-// (or even unguarded) lengths. The fake size is therefore opt-in via
-// as_huge(), and plain strings - in particular object keys - keep reporting
-// their real, small size.
-class huge_string_t : public std::string
-{
-  public:
-    using std::string::string;
-    huge_string_t(const std::string& s) : std::string(s) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-
-    // returns a copy of @a s whose size() pretends to be huge
-    static huge_string_t as_huge(const std::string& s)
-    {
-        huge_string_t result(s);
-        result.pretend_huge = true;
-        return result;
-    }
-
-    size_type size() const noexcept
-    {
-        if (pretend_huge)
-        {
-            // one byte more than the BSON length field can represent
-            return static_cast<size_type>((std::numeric_limits<std::int32_t>::max)()) + 1;
-        }
-        return std::string::size();
-    }
-
-  private:
-    bool pretend_huge = false;
-};
-
-using huge_string_json = nlohmann::basic_json <
-                         std::map, std::vector, huge_string_t, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, std::vector<std::uint8_t>, void >;
 } // namespace

 TEST_CASE("BSON")
@@ -153,36 +105,10 @@ TEST_CASE("BSON")

    SECTION("lengths exceeding INT32_MAX cannot be serialized to BSON")
    {
-        // out_of_range.412 is thrown from a single shared helper
-        // (to_bson_length) that guards the BSON length fields of binary
-        // values, strings, and (embedded) documents alike
-        SECTION("binary")
-        {
-            huge_binary_json j;
-            j["b"] = huge_binary_json::binary(huge_binary_t{});
+        huge_binary_json j;
+        j["b"] = huge_binary_json::binary(huge_binary_t{});

-            CHECK_THROWS_WITH_AS(huge_binary_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_binary_json::out_of_range&);
-        }
-
-        SECTION("string")
-        {
-            huge_string_json j;
-            j["s"] = huge_string_t::as_huge("value");
-
-            CHECK_THROWS_WITH_AS(huge_string_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_string_json::out_of_range&);
-        }
-
-        SECTION("document")
-        {
-            // an oversized string nested one level deep makes the
-            // *embedded* document's own length exceed INT32_MAX as well
-            huge_string_json nested;
-            nested["s"] = huge_string_t::as_huge("value");
-            huge_string_json j;
-            j["nested"] = nested;
-
-            CHECK_THROWS_WITH_AS(huge_string_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483674 exceeds maximum of 2147483647", huge_string_json::out_of_range&);
-        }
+        CHECK_THROWS_WITH_AS(huge_binary_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_binary_json::out_of_range&);
    }

    SECTION("string length must be at least 1")
@@ -199,32 +125,6 @@ TEST_CASE("BSON")
        CHECK_THROWS_WITH_AS(_ = json::from_bson(v), "[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648", json::parse_error&);
    }

-    SECTION("invalid UTF-8 in string (see #5529)")
-    {
-        // a BSON document with a string field "k" whose value bytes are not
-        // valid UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
-        // rejected at decode time, matching every other kind of malformed
-        // binary input, rather than only failing later when the resulting
-        // value is dumped
-        std::vector<std::uint8_t> const v =
-        {
-            0x0F, 0x00, 0x00, 0x00, // size (little endian)
-            0x02, /// entry: string (UTF-8)
-            'k', 0x00, // key "k"
-            0x03, 0x00, 0x00, 0x00, // string length (including trailing zero byte)
-            0xc0, 0xae, // ill-formed UTF-8
-            0x00, // string terminator
-            0x00 // end marker
-        };
-        json _;
-        CHECK_THROWS_WITH_AS(_ = json::from_bson(v), "[json.exception.parse_error.113] parse error at byte 13: syntax error while parsing BSON string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
-        CHECK(json::from_bson(v, true, false).is_discarded());
-
-        // valid UTF-8 must still round-trip
-        const json j = {{"k", "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"}}; // héllo, wörld! 日本語
-        CHECK(json::from_bson(json::to_bson(j)) == j);
-    }
-
    SECTION("objects")
    {
        SECTION("empty object")
@@ -293,23 +193,6 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }

-        SECTION("non-empty object with bool from a non-0/1 byte (lenient parsing)")
-        {
-            // documented lenient behavior (see gh-5333): any non-zero byte
-            // is accepted as `true`, not just 0x01
-            std::vector<std::uint8_t> const input =
-            {
-                0x0D, 0x00, 0x00, 0x00, // size (little endian)
-                0x08,               // entry: boolean
-                'e', 'n', 't', 'r', 'y', '\x00',
-                0x02,           // value = 0x02 (neither 0x00 nor 0x01)
-                0x00                    // end marker
-            };
-
-            const json expected = { { "entry", true } };
-            CHECK(json::from_bson(input) == expected);
-        }
-
        SECTION("non-empty object with double")
        {
            json const j =
@@ -616,29 +499,6 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }

-        SECTION("array elements with non-conforming keys (lenient parsing)")
-        {
-            // documented lenient behavior (see gh-5333): BSON array element
-            // keys are not checked against the required decimal sequence
-            // "0", "1", "2", ... - elements are taken in encoded order
-            std::vector<std::uint8_t> const input =
-            {
-                0x26, 0x00, 0x00, 0x00, // size (little endian)
-                0x04, 'e', 'n', 't', 'r', 'y', '\x00', // entry: embedded array
-
-                0x1A, 0x00, 0x00, 0x00, // size (little endian)
-                0x10, '5', 0x00, 0x0A, 0x00, 0x00, 0x00, // key "5" (bogus)      -> 10
-                0x10, 'x', 0x00, 0x14, 0x00, 0x00, 0x00, // key "x" (non-numeric) -> 20
-                0x10, '1', 0x00, 0x1E, 0x00, 0x00, 0x00, // key "1" (out of order) -> 30
-                0x00, // end marker (embedded array)
-
-                0x00 // end marker
-            };
-
-            const json expected = { { "entry", json::array({10, 20, 30}) } };
-            CHECK(json::from_bson(input) == expected);
-        }
-
        SECTION("non-empty object with binary member")
        {
            const size_t N = 10;
@@ -734,31 +594,6 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }

-        SECTION("binary member with subtype 0x02 (old binary) keeps its inner length prefix (lenient parsing)")
-        {
-            // documented lenient behavior (see gh-5333): the payload for
-            // binary subtype 0x02 ("old binary") is returned as-is,
-            // including its own inner 4-byte length prefix; it is not
-            // stripped or reinterpreted
-            std::vector<std::uint8_t> const input =
-            {
-                0x17, 0x00, 0x00, 0x00, // size (little endian)
-                0x05, 'e', 'n', 't', 'r', 'y', '\x00', // entry: binary
-
-                0x06, 0x00, 0x00, 0x00, // size of binary (little endian)
-                0x02, // "old binary" subtype
-                0x02, 0x00, 0x00, 0x00, // inner length prefix (part of the old-binary payload)
-                0x68, 0x69, // payload ('h', 'i')
-
-                0x00 // end marker
-            };
-
-            // the inner length prefix is part of the (unmodified) payload
-            const std::vector<std::uint8_t> expected_payload = {0x02, 0x00, 0x00, 0x00, 0x68, 0x69};
-            const json expected = { { "entry", json::binary(expected_payload, 0x02) } };
-            CHECK(json::from_bson(input) == expected);
-        }
-
        SECTION("Some more complex document")
        {
            json const j =
@@ -1176,91 +1011,6 @@ TEST_CASE("BSON document size mismatch")
    }
 }

-TEST_CASE("BSON nesting does not consume the call stack")
-{
-    // An embedded document or array used to be read by calling back into the
-    // document reader, so the native call stack grew with the nesting depth of
-    // the input (#5104). The open documents are kept on a heap stack now.
-    //
-    // Deeply nested values must not be compared, copied or dumped here: those
-    // operations are still recursive and would reintroduce the crash.
-
-    // A document nested deeply enough to have crashed. The bytes are built
-    // here rather than with to_bson(), because the writer still recurses once
-    // per level and would overflow the stack before the reader is ever
-    // reached. Every level is
-    //     <int32 size> 0x03 'a' 0x00 <inner document> 0x00
-    // so a level is eight bytes larger than the one it holds, and the sizes
-    // can be filled in from the outside in.
-    const std::size_t depth = 30000;
-    std::vector<uint8_t> input;
-    input.reserve(5 + (8 * depth));
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        const auto size = static_cast<std::uint32_t>(5 + (8 * (depth - i)));
-        input.push_back(static_cast<uint8_t>(size & 0xFF));
-        input.push_back(static_cast<uint8_t>((size >> 8) & 0xFF));
-        input.push_back(static_cast<uint8_t>((size >> 16) & 0xFF));
-        input.push_back(static_cast<uint8_t>((size >> 24) & 0xFF));
-        input.push_back(0x03); // embedded document
-        input.push_back('a');
-        input.push_back(0x00);
-    }
-    // the innermost document is empty, then one terminator closes each level
-    input.insert(input.end(), {0x05, 0x00, 0x00, 0x00, 0x00});
-    input.insert(input.end(), depth, 0x00);
-
-    SECTION("a well-formed deep document is read through the SAX interface")
-    {
-        SaxCountdown accept_all(1000000);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::bson));
-    }
-
-    SECTION("a well-formed deep document is read into a value")
-    {
-        json j = json::from_bson(input);
-
-        // walked rather than compared: comparing, copying or dumping a value
-        // this deep is still recursive
-        std::size_t measured = 0;
-        const json* q = &j;
-        while (q->is_object() && !q->empty())
-        {
-            q = &q->begin().value();
-            ++measured;
-        }
-        CHECK(measured == depth);
-    }
-
-    SECTION("embedded documents and arrays are still read the same way")
-    {
-        const json values = {{"a", {{"b", {{"c", 1}}}}}};
-        CHECK(json::from_bson(json::to_bson(values)) == values);
-
-        const json array = {{"a", {1, 2, 3}}};
-        CHECK(json::from_bson(json::to_bson(array)) == array);
-
-        const json mixed = {{"a", {json{{"x", 1}}, json{{"y", 2}}}}};
-        CHECK(json::from_bson(json::to_bson(mixed)) == mixed);
-
-        CHECK(json::from_bson(json::to_bson(json::object())) == json::object());
-    }
-
-    SECTION("a size that does not match is still reported per document")
-    {
-        // the embedded document claims one byte too many
-        std::vector<uint8_t> const bad =
-        {
-            0x15, 0x00, 0x00, 0x00, 0x03, 'a', 0x00,
-            0x0D, 0x00, 0x00, 0x00, 0x08, 'b', 0x00, 0x01, 0x00,
-            0x00
-        };
-        json _;
-        CHECK_THROWS_AS(_ = json::from_bson(bad), json::parse_error&);
-        CHECK(json::from_bson(bad, true, false).is_discarded());
-    }
-}
-
 TEST_CASE("BSON numerical data")
 {
    SECTION("number")
@@ -1833,27 +1833,6 @@ TEST_CASE("CBOR")
            CHECK(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01}), true, false).is_discarded());
        }

-        SECTION("invalid UTF-8 in string (see #5529)")
-        {
-            // a two-character text string (major type 3) whose bytes are not
-            // valid UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
-            // rejected at decode time, matching every other kind of
-            // malformed binary input, rather than only failing later when
-            // the resulting value is dumped
-            json _;
-            CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x62, 0xc0, 0xae})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
-            CHECK(json::from_cbor(std::vector<uint8_t>({0x62, 0xc0, 0xae}), true, false).is_discarded());
-
-            // a CBOR byte string (major type 2) with the very same bytes is
-            // NOT text and must still be accepted as-is
-            CHECK_NOTHROW(_ = json::from_cbor(std::vector<uint8_t>({0x42, 0xc0, 0xae})));
-            CHECK(_ == json::binary(std::vector<std::uint8_t>({0xc0, 0xae})));
-
-            // valid UTF-8 must still round-trip
-            const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
-            CHECK(json::from_cbor(json::to_cbor(j)) == j);
-        }
-
        SECTION("strict mode")
        {
            std::vector<uint8_t> const vec = {0xf6, 0xf6};
@@ -2056,231 +2035,6 @@ TEST_CASE("CBOR definite length equal to the indefinite-length sentinel")
    }
 }

-TEST_CASE("CBOR nesting does not consume the call stack")
-{
-    // Containers used to be read by calling back into the value reader once
-    // per element, and a tag by calling it for the tagged value, so the native
-    // call stack grew with the nesting depth of the input. Each of the three
-    // costs a single byte to encode -- 0x9F, 0x81 and 0xC2 -- so a payload of
-    // repeated bytes crashed the process (#5104). The containers are kept on a
-    // heap stack now, and a tag is read in a loop.
-    //
-    // Deeply nested values must not be compared, copied or dumped here: those
-    // operations are still recursive and would reintroduce the crash.
-    json _;
-
-    SECTION("indefinite-length containers")
-    {
-        const std::vector<uint8_t> input(500000, 0x9F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("definite-length containers")
-    {
-        const std::vector<uint8_t> input(500000, 0x81);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("tags")
-    {
-        // a tag is not a value of its own, so a chain of them used to recurse
-        const std::vector<uint8_t> input(500000, 0xC2);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input, true, true, json::cbor_tag_handler_t::ignore), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false, json::cbor_tag_handler_t::ignore).is_discarded());
-    }
-
-    SECTION("a well-formed deep value is read through the SAX interface")
-    {
-        std::vector<uint8_t> input(200000, 0x9F);
-        input.insert(input.end(), 200000, 0xFF);
-
-        SaxCountdown accept_all(1000000);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::cbor));
-    }
-
-    SECTION("a well-formed deep value is read into a value")
-    {
-        const std::size_t depth = 10000;
-        std::vector<uint8_t> input(depth, 0x81);
-        input.push_back(0x00);
-
-        json j = json::from_cbor(input);
-
-        std::size_t measured = 0;
-        const json* p = &j;
-        while (p->is_array() && !p->empty())
-        {
-            p = &p->front();
-            ++measured;
-        }
-        CHECK(measured == depth);
-        CHECK(p->is_number());
-    }
-
-    SECTION("containers are still read the same way")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x80})) == json::array());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xA0})) == json::object());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0xFF})) == json::array());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0xFF})) == json::object());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01, 0x02, 0xFF})) == json({1, 2}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 'a', 0x01, 0xFF})) == json({{"a", 1}}));
-        // definite and indefinite forms nested inside each other
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x82, 0x01, 0x02, 0xA1, 0x61, 'k', 0xBF, 0xFF, 0xFF})) == json({{1, 2}, {{"k", json::object()}}}));
-    }
-
-    SECTION("tagged values are still read the same way")
-    {
-        const auto ignore = json::cbor_tag_handler_t::ignore;
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x01}), true, true, ignore) == json(1));
-        // a chain of tags resolves to the value that follows it
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0xC2, 0xC2, 0x01}), true, true, ignore) == json(1));
-        // a tag inside a container, and one in front of a container
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x82, 0xC2, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x82, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
-    }
-}
-
-TEST_CASE("CBOR indefinite-length strings do not recurse per chunk")
-{
-    // Reading an indefinite-length string or byte array used to call itself
-    // once per chunk, so a payload of repeated 0x7F (or 0x5F) bytes exhausted
-    // the call stack before any of the input was rejected. The open levels are
-    // counted now, and the levels below prove the reader still reads the same
-    // values and reports the same errors at the same byte offsets.
-    json _;
-
-    SECTION("many open levels are reported, not crashed on")
-    {
-        const std::vector<uint8_t> input(200000, 0x7F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("many open levels are reported, not crashed on (binary)")
-    {
-        const std::vector<uint8_t> input(200000, 0x5F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR binary: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("chunks are still concatenated")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0xFF})) == json(""));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x61, 0x61, 0xFF})) == json("a"));
-        // nested indefinite-length strings are concatenated across levels
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x61, 0x61, 0xFF, 0x61, 0x62, 0xFF})) == json("ab"));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x7F, 0x61, 0x7A, 0xFF, 0xFF, 0xFF})) == json("z"));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xA1, 0x7F, 0x61, 0x61, 0xFF, 0x01})) == json({{"a", 1}}));
-    }
-
-    SECTION("chunks are still concatenated (binary)")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x41, 0x61, 0xFF})) == json::binary({0x61}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x41, 0x61, 0xFF, 0x41, 0x62, 0xFF})) == json::binary({0x61, 0x62}));
-    }
-
-    SECTION("a chunk that is not a string is still rejected")
-    {
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x00", json::parse_error&);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR binary: expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x00", json::parse_error&);
-    }
-
-    SECTION("a break marker outside an indefinite-length string is not a string")
-    {
-        // 0xFF only closes a string that was opened; on its own it is not one
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0xA1, 0xFF, 0x01})), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xFF", json::parse_error&);
-    }
-}
-
-TEST_CASE("issue #5405 - array reserve for definite-length CBOR arrays")
-{
-#if !defined(JSON_NOEXCEPTION)
-    // this SECTION relies on catching a thrown exception to distinguish
-    // which of two acceptable, bounded rejections a hostile header took;
-    // under JSON_NOEXCEPTION, JSON_THROW never produces a catchable C++
-    // exception (it aborts instead), so this cannot be tested that way here
-    SECTION("a huge claimed length with no element data must not over-allocate")
-    {
-        // 0x9A: array with a four-byte length; claims 0xFFFFFFFF (4294967295)
-        // elements but provides none. max_size() for a std::vector is far
-        // larger than this count, so it does not reject the header outright;
-        // the (capped) reservation must not attempt to allocate space for
-        // billions of elements before the missing data is detected.
-        json _;
-        const std::vector<uint8_t> input = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
-        // On a platform where std::size_t is narrower than 64 bits (e.g.
-        // 32-bit), the claimed count 0xFFFFFFFF coincides with that
-        // platform's detail::unknown_size() sentinel (SIZE_MAX), so the
-        // format-level size check rejects it outright (out_of_range.408,
-        // "excessive ... size") before the SAX consumer's own max_size()
-        // check would even run; on a 64-bit platform it passes both of
-        // those checks and is only found short of data once the (capped)
-        // reservation looks for element bytes that were never provided
-        // (parse_error.110). Either is an acceptable, bounded rejection of
-        // the hostile header -- the property under test is that no path
-        // attempts to allocate space for billions of elements.
-        bool threw = false;
-        try
-        {
-            _ = json::from_cbor(input);
-        }
-        catch (const json::parse_error& e)
-        {
-            threw = true;
-            CHECK(e.id == 110);
-            CHECK(std::string(e.what()) == "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing CBOR value: unexpected end of input");
-        }
-        catch (const json::out_of_range& e)
-        {
-            threw = true;
-            CHECK(e.id == 408);
-            CHECK(std::string(e.what()).find("excessive") != std::string::npos);
-        }
-        CHECK(threw);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-#endif
-
-    SECTION("arrays of various sizes decode to the same value as before the reserve optimization")
-    {
-        for (const auto size :
-                {
-                    std::size_t{0}, std::size_t{1}, std::size_t{5}, // small
-                    std::size_t{16384},                             // exactly at the reserve cap
-                    std::size_t{20000}                              // above the reserve cap
-                })
-        {
-            CAPTURE(size)
-            json j = json::array();
-            for (std::size_t i = 0; i < size; ++i)
-            {
-                j.push_back(static_cast<int>(i % 1000));
-            }
-
-            const auto packed = json::to_cbor(j);
-            CHECK(json::from_cbor(packed) == j);
-        }
-    }
-
-    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-    {
-        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-        // a custom SAX consumer that does not touch a DOM array sees identical events
-        json j = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        const auto packed = json::to_cbor(j);
-
-        SaxCountdown scp(1000000); // large enough to never trigger an abort
-        CHECK(json::sax_parse(packed, &scp, json::input_format_t::cbor));
-    }
-}
-
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {
    SECTION("input from flynn")
@@ -12,11 +12,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

-#include <cstdlib> // strtod
-#include <sstream> // stringstream
-#include <string> // string
-#include <vector> // vector
-
 namespace
 {
 // shortcut to scan a string literal
@@ -229,431 +224,3 @@ TEST_CASE("lexer class")
        CHECK((scan_string("/**//**//**/", true) == json::lexer::token_type::end_of_input));
    }
 }
-
-TEST_CASE("lexer number fast path")
-{
-    // The contiguous fast path (used for pointer/string input) must agree with
-    // the streaming byte path (used for std::istream) on token type, numeric
-    // value, and round-trip text for every well-formed number, and reject the
-    // same malformed numbers with the same message.
-    SECTION("contiguous vs streaming parity")
-    {
-        const std::vector<std::string> numbers =
-        {
-            "0", "-0", "1", "-1", "42", "-42", "10", "100", "1234567890",
-            "0.0", "-0.0", "3.14", "-3.14", "0.5", "-0.001", "123.456789",
-            "1e0", "1E0", "1e10", "1e-10", "1e+10", "1.5e3", "-2.5E-4",
-            "9223372036854775807",             // INT64_MAX -> unsigned
-            "9223372036854775808",             // INT64_MAX + 1 -> unsigned
-            "18446744073709551615",            // UINT64_MAX -> unsigned
-            "18446744073709551616",            // UINT64_MAX + 1 -> float
-            "-9223372036854775808",            // INT64_MIN -> integer
-            "-9223372036854775809",            // INT64_MIN - 1 -> float
-            "123456789012345678901234567890",  // huge -> float
-            "0.30000000000000004", "2.2250738585072014e-308", "1e308",
-            // high-precision / wide-exponent values that exercise the
-            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
-            "1.7976931348623157e308", "1.2345678901234567e-250",
-            "9007199254740993", "5e-324", "1e-320"
-        };
-
-        for (const auto& n : numbers)
-        {
-            const std::string doc = "[" + n + "]";
-
-            // contiguous fast path
-            const json a = json::parse(doc);
-            // streaming byte path
-            std::stringstream ss(doc);
-            const json b = json::parse(ss);
-
-            CAPTURE(n);
-            CHECK(a == b);
-            CHECK(a.dump() == b.dump());
-            CHECK(a[0].type() == b[0].type());
-        }
-    }
-
-    SECTION("significant-digit gate for the Clinger fast path")
-    {
-        // Clinger's fast path needs a significand below 2^53, so it cannot
-        // succeed once the mantissa has 17 or more significant digits (the
-        // significand would be at least 10^16). The lexer skips the attempt
-        // there. That is only allowed to save work: every value must still come
-        // out bit-exactly, and both scanners must agree. In particular the gate
-        // must not fire for tokens whose leading zeros merely look like extra
-        // digits - "0.1234567890123456" has 16 significant digits, not 17.
-        const std::vector<std::string> numbers =
-        {
-            "1234567890123456",                  // 16 significant digits
-            "12345678901234567",                 // 17 -> attempt skipped
-            "123456789012345678",                // 18 -> attempt skipped
-            "0.1234567890123456",                // 16: the leading "0" is not significant
-            "0.12345678901234567",               // 17
-            "0.00000000000000001",               // 1, in a long token
-            "0.000000000000000012345678901234",  // 14, in a long token
-            "-0.0000000000000000000001",         // 1, negative
-            "1.0000000000000000",                // 17: trailing zeros are significant here
-            "10000000000000000",                 // 17
-            "9007199254740992",                  // 2^53
-            "9007199254740993",                  // 2^53 + 1
-            "-65.613616999999977",               // canada.json shape
-            "1.2345678901234567e-250",           // 17 with an exponent
-            "1.234567890123456e-250",            // 16 with an exponent
-            "1e10", "0.0", "-0.0", "0e0", "0.000123"
-        };
-
-        for (const auto& n : numbers)
-        {
-            CAPTURE(n);
-            const std::string doc = "[" + n + "]";
-
-            const json a = json::parse(doc);   // contiguous fast path
-            std::stringstream ss(doc);
-            const json b = json::parse(ss);    // streaming byte path
-
-            CHECK(a[0].type() == b[0].type());
-            CHECK(a == b);
-
-            if (a[0].is_number_float())
-            {
-                const double expected = std::strtod(n.c_str(), nullptr);
-                CHECK(a[0].get<double>() == expected);
-                CHECK(b[0].get<double>() == expected);
-            }
-        }
-    }
-
-    SECTION("token type classification")
-    {
-        CHECK((scan_string("0") == json::lexer::token_type::value_unsigned));
-        CHECK((scan_string("-1") == json::lexer::token_type::value_integer));
-        CHECK((scan_string("1.5") == json::lexer::token_type::value_float));
-        CHECK((scan_string("1e5") == json::lexer::token_type::value_float));
-        CHECK((scan_string("18446744073709551615") == json::lexer::token_type::value_unsigned));
-        CHECK((scan_string("18446744073709551616") == json::lexer::token_type::value_float));
-        CHECK((scan_string("-9223372036854775808") == json::lexer::token_type::value_integer));
-        CHECK((scan_string("-9223372036854775809") == json::lexer::token_type::value_float));
-    }
-
-    SECTION("malformed numbers are rejected identically")
-    {
-        for (const char* bad :
-                {"-", "1.", "1e", "1e+", "1.2e", "01", "-01", "1..2", "1.2.3"
-                })
-        {
-            CAPTURE(bad);
-            // the contiguous fast path must decline and let the byte path report
-            const std::string doc = std::string("[") + bad + "]";
-            CHECK_FALSE(json::accept(doc));
-            std::stringstream ss(doc);
-            CHECK_FALSE(json::accept(ss));
-        }
-    }
-
-#if !defined(JSON_NOEXCEPTION)
-    // these sections parse invalid input, which aborts when exceptions are off
-    SECTION("exhaustive grammar parity with the streaming path")
-    {
-        // The JSON number grammar is encoded twice: once as the scan_number()
-        // state machine and once as the contiguous fast path. Enumerate every
-        // short string over the number alphabet and require the two encodings to
-        // agree exactly - on acceptance, on the reported error, and on the parsed
-        // value - so they cannot drift apart.
-        const std::string alphabet = "01.eE+-";
-
-        // full outcome of parsing @a doc, so a mismatch in type, value, or error
-        // message is caught, not just a mismatch in acceptance
-        const auto outcome = [](const std::string & doc, bool streaming) -> std::string
-        {
-            try
-            {
-                if (streaming)
-                {
-                    std::stringstream ss(doc);
-                    const json j = json::parse(ss);
-                    return std::string(j[0].type_name()) + '|' + j.dump();
-                }
-                const json j = json::parse(doc);
-                return std::string(j[0].type_name()) + '|' + j.dump();
-            }
-            catch (const json::parse_error& e)
-            {
-                return {e.what()};
-            }
-        };
-
-        std::vector<std::string> mismatches;
-        std::vector<std::string> tokens{""};
-        for (std::size_t length = 1; length <= 4; ++length)
-        {
-            std::vector<std::string> next;
-            next.reserve(tokens.size() * alphabet.size());
-            for (const auto& prefix : tokens)
-            {
-                for (const char c : alphabet)
-                {
-                    next.push_back(prefix + c);
-                }
-            }
-            tokens = next;
-
-            for (const auto& token : tokens)
-            {
-                const std::string doc = "[" + token + "]";
-                if (outcome(doc, false) != outcome(doc, true))
-                {
-                    mismatches.push_back(doc);
-                }
-            }
-        }
-
-        // 7 + 49 + 343 + 2401 tokens
-        CHECK(tokens.size() == 2401);
-        CAPTURE(mismatches);
-        CHECK(mismatches.empty());
-    }
-
-    SECTION("error positions match the streaming path")
-    {
-        // Rejecting identically is not enough: the fast path must also report the
-        // error at the same position as the byte path. A number directly followed
-        // by a newline is the interesting case, because the byte path reaches the
-        // newline (which resets the column) and then ungets it.
-        // returns the parse_error message, or "" if the document parsed
-        const auto contiguous_error = [](const std::string & doc) -> std::string
-        {
-            try
-            {
-                const json j = json::parse(doc);
-                static_cast<void>(j);
-            }
-            catch (const json::parse_error& e)
-            {
-                return {e.what()};
-            }
-            return {};
-        };
-        const auto streaming_error = [](const std::string & doc) -> std::string
-        {
-            try
-            {
-                std::stringstream ss(doc);
-                const json j = json::parse(ss);
-                static_cast<void>(j);
-            }
-            catch (const json::parse_error& e)
-            {
-                return {e.what()};
-            }
-            return {};
-        };
-
-        for (const char* bad :
-                {"[01\n]", "[00\n]", "[-01\n]", "{1\n}", "[1\n2]", "[1.2.3\n]",
-                 "[1 \n2]", "[\n1\n2]", "1\n2", "[01\r\n]", "[1e\n]", "[-\n]"
-                })
-        {
-            CAPTURE(bad);
-            const std::string doc = bad;
-            const std::string contiguous_what = contiguous_error(doc);
-
-            CHECK_FALSE(contiguous_what.empty());
-            CHECK(contiguous_what == streaming_error(doc));
-        }
-
-        // A number terminated by a newline must report the same position as the
-        // same number terminated by anything else: scan_number() reads the
-        // terminator and ungets it, so the reported column is the one reached
-        // after the number's last character - not the 0 that an unget() across
-        // the newline used to leave behind.
-        CHECK(contiguous_error("[01\n]") == contiguous_error("[01 ]"));
-        CHECK(contiguous_error("[01\n]") ==
-              "[json.exception.parse_error.101] parse error at line 1, column 3: "
-              "syntax error while parsing array - unexpected number literal; expected ']'");
-
-        // the same for a multi-character token, where the column of the last
-        // character (the '3' of "-2.5e3") differs from the column it starts at
-        CHECK(contiguous_error("null -2.5e3\nfalse") == contiguous_error("null -2.5e3 false"));
-        CHECK(contiguous_error("null -2.5e3\nfalse") ==
-              "[json.exception.parse_error.101] parse error at line 1, column 11: "
-              "syntax error while parsing value - unexpected number literal; expected end of input");
-    }
-#endif
-}
-
-TEST_CASE("lexer string fast path")
-{
-    // Build a byte string from explicit values: a hex escape in a string
-    // literal swallows every following hex digit, which makes sequences like
-    // "\xC3\xA9b" mean something other than they look like.
-    const auto bytes = [](std::initializer_list<int> values)
-    {
-        std::string result;
-        for (const int value : values)
-        {
-            result.push_back(static_cast<char>(value));
-        }
-        return result;
-    };
-
-#if !defined(JSON_NOEXCEPTION)
-    // the full outcome of parsing @a doc: the parsed value, or the exact error
-    // message, so a mismatch in either is caught. Only usable with exceptions
-    // on: parsing invalid input aborts when they are off.
-    const auto outcome = [](const std::string & doc, bool streaming) -> std::string
-    {
-        try
-        {
-            if (streaming)
-            {
-                std::stringstream ss(doc);
-                const json j = json::parse(ss);
-                return j.dump();
-            }
-            const json j = json::parse(doc);
-            return j.dump();
-        }
-        // not just parse_error: if a bulk scanner ever let ill-formed UTF-8
-        // through, dump() would throw type_error.316, and that has to surface
-        // as a reported mismatch rather than as an uncaught exception
-        catch (const json::exception& e)
-        {
-            return {e.what()};
-        }
-    };
-#endif
-
-    // once at the start of the string, once past the first 8-byte SWAR word, so
-    // the bulk scanner sees each case with and without a run behind it
-    const std::vector<std::size_t> offsets{0, 9};
-
-#if !defined(JSON_NOEXCEPTION)
-    SECTION("exhaustive contiguous vs streaming parity")
-    {
-        // ordinary ASCII, both specials, a control byte, characters that make
-        // the preceding backslash a valid escape, a UTF-8 lead byte of each
-        // length, a continuation byte, and a byte that is never valid
-        const std::vector<std::string> alphabet =
-        {
-            "a", "\"", "\\", "n", "u", "0", bytes({0x01}),
-            bytes({0xC3}), bytes({0xA9}), bytes({0xE4}), bytes({0xF0}),
-            bytes({0x80}), bytes({0xFF})
-        };
-
-        std::vector<std::string> mismatches;
-        std::vector<std::string> tokens{""};
-        for (std::size_t length = 1; length <= 3; ++length)
-        {
-            std::vector<std::string> next;
-            next.reserve(tokens.size() * alphabet.size());
-            for (const auto& prefix : tokens)
-            {
-                for (const auto& symbol : alphabet)
-                {
-                    next.push_back(prefix + symbol);
-                }
-            }
-            tokens = next;
-
-            for (const auto& token : tokens)
-            {
-                for (const std::size_t offset : offsets)
-                {
-                    const std::string doc = "[\"" + std::string(offset, 'a') + token + "\"]";
-                    if (outcome(doc, false) != outcome(doc, true))
-                    {
-                        mismatches.push_back(doc);
-                    }
-                }
-            }
-        }
-
-        // 13 + 169 + 2197 tokens, each at two offsets
-        CHECK(tokens.size() == 2197);
-        CAPTURE(mismatches);
-        CHECK(mismatches.empty());
-    }
-
-    SECTION("special bytes at every offset of the SWAR stride")
-    {
-        // The bulk scanner consumes 8 bytes at a time and then a tail; place
-        // every kind of byte that ends a run at each offset across two words,
-        // so multibyte sequences also straddle the word boundary.
-        const std::vector<std::string> specials =
-        {
-            "\"", "\\", bytes({0x01}), bytes({0x1F}), bytes({0x7F}),
-            bytes({0xC3, 0xA9}), bytes({0xE4, 0xB8, 0xAD}), bytes({0xF0, 0x9F, 0x98, 0x80}),
-            bytes({0xFF}), bytes({0xC3}), bytes({0xE4, 0xB8})
-        };
-
-        std::vector<std::string> mismatches;
-        for (std::size_t offset = 0; offset <= 17; ++offset)
-        {
-            for (const auto& special : specials)
-            {
-                const std::string doc = "[\"" + std::string(offset, 'a') + special + "\"]";
-                if (outcome(doc, false) != outcome(doc, true))
-                {
-                    mismatches.push_back(doc);
-                }
-            }
-        }
-        CAPTURE(mismatches);
-        CHECK(mismatches.empty());
-    }
-#endif
-
-    // json::accept() never throws, so the ranges stay covered without exceptions
-    SECTION("UTF-8 ranges are accepted and rejected as documented")
-    {
-        // The bulk validator must accept exactly what the byte-at-a-time
-        // scanner accepts, so pin the boundaries of every range it recognizes.
-        // aggregate, only ever brace-initialized below; default member
-        // initializers would stop it being an aggregate in C++11
-        struct utf8_case // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
-        {
-            std::string sequence;
-            bool valid;
-            const char* description;
-        };
-        const std::vector<utf8_case> cases =
-        {
-            {bytes({0xC2, 0x80}), true, "U+0080, shortest two-byte"},
-            {bytes({0xDF, 0xBF}), true, "U+07FF, longest two-byte"},
-            {bytes({0xC1, 0xBF}), false, "overlong two-byte"},
-            {bytes({0xC2, 0x7F}), false, "two-byte with bad continuation"},
-            {bytes({0xE0, 0xA0, 0x80}), true, "U+0800, shortest three-byte"},
-            {bytes({0xE0, 0x9F, 0xBF}), false, "overlong three-byte"},
-            {bytes({0xED, 0x9F, 0xBF}), true, "U+D7FF, just below the surrogates"},
-            {bytes({0xED, 0xA0, 0x80}), false, "surrogate U+D800"},
-            {bytes({0xED, 0xBF, 0xBF}), false, "surrogate U+DFFF"},
-            {bytes({0xEE, 0x80, 0x80}), true, "U+E000, just above the surrogates"},
-            {bytes({0xEF, 0xBF, 0xBF}), true, "U+FFFF"},
-            {bytes({0xF0, 0x90, 0x80, 0x80}), true, "U+10000, shortest four-byte"},
-            {bytes({0xF0, 0x8F, 0xBF, 0xBF}), false, "overlong four-byte"},
-            {bytes({0xF4, 0x8F, 0xBF, 0xBF}), true, "U+10FFFF, highest code point"},
-            {bytes({0xF4, 0x90, 0x80, 0x80}), false, "above U+10FFFF"},
-            {bytes({0xF5, 0x80, 0x80, 0x80}), false, "lead byte out of range"},
-            {bytes({0x80}), false, "bare continuation byte"},
-            {bytes({0xFF}), false, "byte that never appears in UTF-8"},
-            {bytes({0xC3}), false, "truncated two-byte"},
-            {bytes({0xE4, 0xB8}), false, "truncated three-byte"},
-            {bytes({0xF0, 0x9F, 0x98}), false, "truncated four-byte"}
-        };
-
-        for (const auto& test_case : cases)
-        {
-            CAPTURE(test_case.description);
-            for (const std::size_t offset : offsets)
-            {
-                CAPTURE(offset);
-                const std::string doc = "[\"" + std::string(offset, 'a') + test_case.sequence + "\"]";
-                CHECK(json::accept(doc) == test_case.valid);
-#if !defined(JSON_NOEXCEPTION)
-                CHECK(outcome(doc, false) == outcome(doc, true));
-#endif
-            }
-        }
-    }
-}
@@ -23,8 +23,6 @@ using nlohmann::json;
 #include <utility>
 #include <vector>

-#include "test_utils.hpp"
-
 namespace
 {
 class SaxEventLogger
@@ -346,50 +344,6 @@ void trailing_comma_helper(const std::string& s)
    }
 }

-#if JSON_DIAGNOSTIC_POSITIONS
-/**
- * Validates that the generated JSON object is the same as expected
- * Validates that the start position and end position match the start and end of the string
- *
- * This check assumes that there is no whitespace around the json object in the original string.
- */
-void validate_generated_json_and_start_end_pos_helper(const std::string& original_string, const json& j, const json& check)
-{
-    CHECK(j == check);
-    CHECK(j.start_pos() == 0);
-    CHECK(j.end_pos() == original_string.size());
-}
-
-/**
- * Parses the root object from the given root string and validates that the start and end positions for the nested object are correct.
- *
- * This checks that whitespace around the nested object is included in the start and end positions of the root object.
- */
-void validate_start_end_pos_for_nested_obj_helper(const std::string& nested_type_json_str, const std::string& root_type_json_str, const json& expected_json, const json::parser_callback_t& cb = nullptr)
-{
-    json j;
-
-    // 1. If callback is provided, use callback version of parse()
-    if (cb)
-    {
-        j = json::parse(root_type_json_str, cb);
-    }
-    else
-    {
-        j = json::parse(root_type_json_str);
-    }
-
-    // 2. Check if the generated JSON is as expected
-    // Assumptions: The root_type_json_str does not have any whitespace around the json object
-    validate_generated_json_and_start_end_pos_helper(root_type_json_str, j, expected_json);
-
-    // 3. Get the nested object
-    const auto& nested = j["nested"];
-    // 4. Check if the start and end positions are generated correctly for nested objects and arrays
-    CHECK(nested_type_json_str == root_type_json_str.substr(nested.start_pos(), nested.end_pos() - nested.start_pos()));
-}
-#endif
-
 } // namespace

 TEST_CASE("parser class")
@@ -670,8 +624,7 @@ TEST_CASE("parser class")
            SECTION("overflow")
            {
                // overflows during parsing yield an exception
-                // empty() is nodiscard; the exception is thrown by parser_helper() itself, before empty() would run
-                CHECK_THROWS_WITH_AS(utils::ignore_return_value(parser_helper("1.18973e+4932").empty()), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
+                CHECK_THROWS_WITH_AS(parser_helper("1.18973e+4932").empty(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'", json::out_of_range&);
            }

            SECTION("invalid numbers")
@@ -977,98 +930,6 @@ TEST_CASE("parser class")
                CHECK(accept_helper("+1") == false);
                CHECK(accept_helper("+0") == false);
            }
-
-            SECTION("issue #5411 - skip conversion when accept() does not need the numeric value")
-            {
-                // lexer::scan_number() may skip strtoull()/strtoll() for
-                // value_unsigned/value_integer tokens when the caller (e.g.
-                // json::accept()) does not need the converted value, as long
-                // as the digit count alone guarantees no 64-bit overflow (see
-                // the "safe_digit_count" fast path in scan_number()). This
-                // differential test checks that json::accept() (which enables
-                // the fast path) and json::parse() (which never does) always
-                // agree, over a corpus that exercises both the fast path
-                // (<=18 digits) and the untouched, exact fallback path (>=19
-                // digits) -- including reclassification of huge digit-only
-                // integers to a (possibly non-finite) floating-point value.
-                const std::vector<std::pair<std::string, bool>> cases =
-                {
-                    // normal small/large integers, both signs
-                    {"0", true}, {"1", true}, {"-1", true}, {"42", true}, {"-42", true},
-                    {"123456789", true}, {"-123456789", true},
-
-                    // digit-count boundary around the 18-digit safe cutoff (both signs)
-                    {std::string(17, '9'), true},
-                    {std::string(18, '9'), true},
-                    {std::string(19, '9'), true},
-                    {std::string(20, '9'), true},
-                    {"-" + std::string(17, '9'), true},
-                    {"-" + std::string(18, '9'), true},
-                    {"-" + std::string(19, '9'), true},
-                    {"-" + std::string(20, '9'), true},
-
-                    // 64-bit boundaries
-                    {"9223372036854775807", true},    // INT64_MAX
-                    {"-9223372036854775808", true},   // INT64_MIN
-                    {"18446744073709551615", true},   // UINT64_MAX
-                    {"18446744073709551616", true},   // UINT64_MAX + 1 (overflows uint64_t, finite double)
-
-                    // the 28-digit example from the issue: overflows uint64_t
-                    // but is finite as a double, so the scanner reclassifies
-                    // it to value_float and it is accepted
-                    {"9999999999999999999999999999", true},
-
-                    // huge digit-only integers that overflow even a double -> rejected
-                    {std::string(309, '9'), false},
-                    {std::string(400, '9'), false},
-                    {"1" + std::string(400, '0'), false},
-
-                    // 1e999 / 1e400 style overflow -> rejected
-                    {"1e999", false},
-                    {"1e400", false},
-                    {"-1e999", false},
-                    {"1E999", false},
-
-                    // values straddling DBL_MAX
-                    {"1.7976931348623157e308", true},   // <= DBL_MAX, finite
-                    {"1.7976931348623159e308", false},  // > DBL_MAX, overflows to inf
-
-                    // a mix of other valid/invalid numeric syntax
-                    {"3.14159", true},
-                    {"-0.0", true},
-                    {"1.0e10", true},
-                    {"01", false},
-                    {"-", false},
-                    {"1.", false},
-                    {"1e", false},
-                    {"+1", false},
-                };
-
-                for (const auto& c : cases)
-                {
-                    const std::string& number = c.first;
-                    const bool expected = c.second;
-                    CAPTURE(number)
-                    CAPTURE(expected)
-
-                    // accept() takes the fast path (skips conversion when possible)
-                    CHECK(json::accept(number) == expected);
-
-                    // parse() always performs the full conversion; it must agree
-                    json j;
-                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter(number), nullptr, false).parse(true, j));
-                    CHECK(!j.is_discarded() == expected);
-
-                    // wrap in an array so get_token() is exercised beyond the
-                    // very first (constructor-time) scan as well
-                    std::string wrapped = "[";
-                    wrapped += number;
-                    wrapped += ",";
-                    wrapped += number;
-                    wrapped += "]";
-                    CHECK(json::accept(wrapped) == expected);
-                }
-            }
        }
    }

@@ -1533,71 +1394,6 @@ TEST_CASE("parser class")
        CHECK(accept_helper("\"\\uD80C\\uFFFF\"") == false);
    }

-#if !defined(JSON_NOEXCEPTION)
-    SECTION("issue #5412 - whitespace skipping bookkeeping (compact vs. pretty-printed)")
-    {
-        // lexer::skip_whitespace() reads its first character with get() (to
-        // honor a possibly pending unget() from the previous token) and every
-        // further whitespace character with get_ignoring_pending_unget() (a
-        // get() variant that skips the then-always-false next_unget check).
-        // This must not change the reported byte offset, line, or column of
-        // a syntax error, even when a long run of whitespace containing
-        // multiple newlines is skipped beforehand (as with pretty-printed
-        // input). The expected values below were captured from the
-        // unmodified do-while(get()) loop, so any regression that miscounts
-        // characters or newlines while skipping whitespace changes them.
-        const auto check_error = [](const std::string & input, std::size_t expected_byte,
-                                    const std::string & expected_what)
-        {
-            CAPTURE(input)
-            try
-            {
-                json _ = json::parse(input);
-                FAIL_CHECK("expected a parse_error, but parsing succeeded");
-            }
-            catch (const json::parse_error& e)
-            {
-                CHECK(e.byte == expected_byte);
-                CHECK(std::string(e.what()) == expected_what);
-            }
-        };
-
-        // a nested document, serialized both compactly and pretty-printed
-        // (dump(4)), each truncated right before the final closing '}' so
-        // that the parser hits EOF after skipping all of the (in the
-        // pretty-printed case, substantial) indentation whitespace
-        const json doc =
-        {
-            {"a", 1},
-            {"b", json::array({true, false, nullptr, "x"})},
-            {"c", json::object({{"d", 3.14}, {"e", json::array({1, 2, 3})}})}
-        };
-
-        const std::string compact = doc.dump();
-        const std::string pretty = doc.dump(4);
-
-        check_error(compact.substr(0, compact.size() - 1), 60,
-                    "[json.exception.parse_error.101] parse error at line 1, column 60: syntax error while parsing object - unexpected end of input; expected '}'");
-        check_error(pretty.substr(0, pretty.size() - 1), 193,
-                    "[json.exception.parse_error.101] parse error at line 17, column 1: syntax error while parsing object - unexpected end of input; expected '}'");
-
-        // an invalid token appearing after several indented, multi-line
-        // whitespace runs vs. the same document without any of that
-        // whitespace
-        check_error(R"({
-    "a": 1,
-    "b": [
-        true,
-        false
-    ],
-    "c": @
-})", 70,
-                    "[json.exception.parse_error.101] parse error at line 7, column 10: syntax error while parsing value - invalid literal; last read: '\"c\": @'");
-        check_error(R"({"a":1,"b":[true,false],"c":@})", 29,
-                    "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing value - invalid literal; last read: '\"c\":@'");
-    }
-#endif
-
    SECTION("tests found by mutate++")
    {
        // test case to make sure no comma precedes the first key
@@ -1768,58 +1564,6 @@ TEST_CASE("parser class")
            CHECK (j_filtered2 == json({{"foo", {1, 2}}}));
        }

-        SECTION("filter many members of one container")
-        {
-            // Rejecting a value makes the parser remove the placeholder its key
-            // event stored. Locating that placeholder used to be a scan of the
-            // whole parent, which made filtering a large container quadratic:
-            // 128k members took ~25 s. These cases keep many members alive
-            // while discarding many others, so the removal cost is the whole
-            // point; they run in milliseconds when the placeholder is erased
-            // directly.
-            constexpr int count = 20000;
-
-            std::string s = "{";
-            for (int i = 0; i < count; ++i)
-            {
-                // "a<i>" is kept, "z<i>" is discarded
-                s += "\"a" + std::to_string(i) + "\":" + std::to_string(i) + ",";
-                s += "\"z" + std::to_string(i) + "\":-1,";
-            }
-            s.back() = '}';
-
-            const json j_values = json::parse(s, [](int /*unused*/, json::parse_event_t e, const json & parsed) noexcept
-            {
-                return !(e == json::parse_event_t::value && parsed == json(-1));
-            });
-
-            CHECK(j_values.size() == count);
-            CHECK(j_values.at("a0") == json(0));
-            CHECK(j_values.at("a" + std::to_string(count - 1)) == json(count - 1));
-            CHECK_FALSE(j_values.contains("z0"));
-            CHECK_FALSE(j_values.contains("z" + std::to_string(count - 1)));
-
-            // the same, but discarding whole containers rather than values,
-            // which takes the end_object()/end_array() removal path
-            std::string s_nested = "{";
-            for (int i = 0; i < count; ++i)
-            {
-                s_nested += "\"a" + std::to_string(i) + "\":" + std::to_string(i) + ",";
-                s_nested += "\"z" + std::to_string(i) + "\":[1,2],";
-            }
-            s_nested.back() = '}';
-
-            const json j_arrays = json::parse(s_nested, [](int /*unused*/, json::parse_event_t e, const json& /*unused*/) noexcept
-            {
-                return e != json::parse_event_t::array_end;
-            });
-
-            CHECK(j_arrays.size() == count);
-            CHECK(j_arrays.at("a0") == json(0));
-            CHECK_FALSE(j_arrays.contains("z0"));
-            CHECK_FALSE(j_arrays.contains("z" + std::to_string(count - 1)));
-        }
-
        SECTION("filter specific events")
        {
            SECTION("first closing event")
@@ -2035,310 +1779,8 @@ TEST_CASE("parser class")
        CHECK_THROWS_WITH_AS(_ = json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
        CHECK_THROWS_WITH_AS(_ = json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
    }
-
-#if JSON_DIAGNOSTIC_POSITIONS
-    // Macro for all test cases for start_pos and end_pos
-#define SETUP_TESTCASES() \
-    SECTION("with callback") \
-    { \
-        SECTION("filter nothing") \
-        { \
-            json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept \
-            { \
-                return true; \
-            }; \
-            validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected, cb); \
-        } \
-        SECTION("filter element") \
-        { \
-            json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t event, json& j) noexcept \
-            { \
-                return (event != json::parse_event_t::key && event != json::parse_event_t::value) || j != json("a"); \
-            }; \
-            validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, filteredExpected, cb); \
-        } \
-    } \
-    SECTION("without callback") \
-    { \
-        validate_start_end_pos_for_nested_obj_helper(nested_type_json_str, root_type_json_str, expected); \
-    }
-
-    SECTION("retrieve start position and end position")
-    {
-        SECTION("for object")
-        {
-            // Create an object with spaces to test the start and end positions. Spaces will not be included in the
-            // JSON object, however, the start and end positions should include the spaces from the input JSON string.
-            const std::string nested_type_json_str =  R"({    "a":       1,"b"      : "test1"})";
-            const std::string root_type_json_str =  R"({    "nested": )" + nested_type_json_str + R"(, "anotherValue": "test2"})";
-            auto expected = json({{"nested", {{"a", 1}, {"b", "test1"}}}, {"anotherValue", "test2"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"].erase("a");
-
-            SETUP_TESTCASES()
-        }
-
-        SECTION("for array")
-        {
-            const std::string nested_type_json_str =  R"(["a", "test", 45])";
-            const std::string root_type_json_str =  R"({   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"nested", {"a", "test", 45}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"] = json({"test", 45});
-            SETUP_TESTCASES()
-        }
-
-        SECTION("for array with objects")
-        {
-            const std::string nested_type_json_str =  R"([{"a": 1, "b": "test"}, {"c": 2, "d": "test2"}])";
-            const std::string root_type_json_str =  R"({   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"nested", {{{"a", 1}, {"b", "test"}}, {{"c", 2}, {"d", "test2"}}}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected["nested"][0].erase("a");
-            SETUP_TESTCASES()
-
-            auto j = json::parse(root_type_json_str);
-            auto nested_array = j["nested"];
-            const auto& nested_obj = nested_array[0];
-            CHECK(nested_type_json_str.substr(1, 21) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
-            CHECK(nested_type_json_str.substr(24, 22) == root_type_json_str.substr(nested_array[1].start_pos(), nested_array[1].end_pos() - nested_array[1].start_pos()));
-        }
-
-        SECTION("for two levels of nesting objects")
-        {
-            const std::string nested_type_json_str =  R"({"nested2": {"b": "test"}})";
-            const std::string root_type_json_str =  R"({   "a": 2, "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-            auto expected = json({{"a", 2}, {"nested", {{"nested2", {{"b", "test"}}}}}, {"anotherValue", "test"}});
-            auto filteredExpected = expected;
-            filteredExpected.erase("a");
-            SETUP_TESTCASES()
-
-            auto j = json::parse(root_type_json_str);
-            auto nested_obj = j["nested"]["nested2"];
-            CHECK(nested_type_json_str.substr(12, 13) == root_type_json_str.substr(nested_obj.start_pos(), nested_obj.end_pos() - nested_obj.start_pos()));
-        }
-
-        SECTION("for simple types")
-        {
-            SECTION("no nested")
-            {
-                SECTION("with callback")
-                {
-                    json::parser_callback_t const cb = [](int /*unused*/, json::parse_event_t /*unused*/, json& /*unused*/) noexcept
-                    {
-                        return true;
-                    };
-
-                    // 1. string type
-                    std::string json_str =  R"("test")";
-                    auto j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
-
-                    // 2. number type
-                    json_str =  R"(1)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
-
-                    // 3. boolean type
-                    json_str =  R"(true)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, true);
-
-                    // 4. null type
-                    json_str =  R"(null)";
-                    j = json::parse(json_str, cb);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
-                }
-
-                SECTION("without callback")
-                {
-                    // 1. string type
-                    std::string json_str =  R"("test")";
-                    auto j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, "test");
-
-                    // 2. number type
-                    json_str =  R"(1)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1);
-
-                    json_str = R"(1.001239923)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1.001239923);
-
-                    json_str = R"(1.123812389000000)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, 1.123812389);
-
-                    // 3. boolean type
-                    json_str =  R"(true)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, true);
-
-                    json_str =  R"(false)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, false);
-
-                    // 4. null type
-                    json_str =  R"(null)";
-                    j = json::parse(json_str);
-                    validate_generated_json_and_start_end_pos_helper(json_str, j, nullptr);
-                }
-            }
-
-            SECTION("string type")
-            {
-                const std::string nested_type_json_str =  R"("test")";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", "test"}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("number type")
-            {
-                const std::string nested_type_json_str =  R"(2)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", 2}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("boolean type")
-            {
-                const std::string nested_type_json_str =  R"(true)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", true}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-
-            SECTION("null type")
-            {
-                const std::string nested_type_json_str =  R"(null)";
-                const std::string root_type_json_str =  R"({ "a": 1,   "nested": )" + nested_type_json_str + R"(, "anotherValue": "test" })";
-                auto expected = json({{"nested", nullptr}, {"anotherValue", "test"}, {"a", 1}});
-                auto filteredExpected = expected;
-                filteredExpected.erase("a");
-                SETUP_TESTCASES()
-            }
-        }
-        SECTION("with leading whitespace and newlines around root JSON")
-        {
-            const std::string initial_whitespace = R"(
-                
-            )";
-            const std::string nested_type_json_str = R"({
-                "a": 1,
-                "nested": {
-                    "b": "test"
-                },
-                "anotherValue": "test"
-            })";
-            const std::string end_whitespace = R"(
-                
-            )";
-            const std::string root_type_json_str = initial_whitespace + nested_type_json_str + end_whitespace;
-
-            auto expected = json({{"a", 1}, {"nested", {{"b", "test"}}}, {"anotherValue", "test"}});
-
-            auto j = json::parse(root_type_json_str);
-
-            // 2. Check if the generated JSON is as expected
-            CHECK(j == expected);
-
-            // 3. Check if the start and end positions do not include the surrounding whitespace
-            CHECK(j.start_pos() == initial_whitespace.size());
-            CHECK(j.end_pos() == root_type_json_str.size() - end_whitespace.size());
-        }
-    }
-#undef SETUP_TESTCASES
-#endif
 }

-#if JSON_DIAGNOSTIC_POSITIONS
-
-TEST_CASE("diagnostic positions: value lifetime")
-{
-    SECTION("copy constructor copies positions, recursively")
-    {
-        const std::string s = R"({"a":1,"b":[1,2,3]})";
-        const json a = json::parse(s);
-        const json b = a; // NOLINT(performance-unnecessary-copy-initialization)
-
-        CHECK(b.start_pos() == a.start_pos());
-        CHECK(b.end_pos() == a.end_pos());
-        CHECK(b["b"].start_pos() == a["b"].start_pos());
-        CHECK(b["b"].end_pos() == a["b"].end_pos());
-    }
-
-    SECTION("move constructor resets the moved-from value to npos")
-    {
-        const std::string s = R"({"a":1,"b":[1,2,3]})";
-        json a = json::parse(s);
-        const auto a_start = a.start_pos();
-        const auto a_end = a.end_pos();
-
-        const json b(std::move(a));
-
-        CHECK(b.start_pos() == a_start);
-        CHECK(b.end_pos() == a_end);
-
-        CHECK(a.start_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-        CHECK(a.end_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-    }
-
-    SECTION("swap() exchanges positions along with the values")
-    {
-        // basic_json::swap() (and the friend swap() that forwards to it) used
-        // to swap only m_data.m_type/m_data.m_value, leaving
-        // start_position/end_position untouched -- unlike copy-assignment's
-        // operator=(basic_json), which swaps positions as part of its
-        // copy-and-swap implementation. After swap(a, b), each value ended up
-        // with the *other* value's content but its *own* original position.
-        // This is now fixed so that swap() is consistent with copy-assignment.
-        json a = json::parse(R"({"a":1})");
-        json b = json::parse(R"([1,2,3,4,5])");
-        const auto a_start = a.start_pos();
-        const auto a_end = a.end_pos();
-        const auto b_start = b.start_pos();
-        const auto b_end = b.end_pos();
-        // lengths (and thus end positions) differ, which is enough to tell
-        // after the swap whether positions actually moved with the values
-        CHECK(a_end != b_end);
-
-        using std::swap;
-        swap(a, b);
-
-        CHECK(a == json::parse(R"([1,2,3,4,5])"));
-        CHECK(b == json::parse(R"({"a":1})"));
-
-        CHECK(a.start_pos() == b_start);
-        CHECK(a.end_pos() == b_end);
-        CHECK(b.start_pos() == a_start);
-        CHECK(b.end_pos() == a_end);
-
-        // member swap() behaves the same as the free function
-        json c = json::parse(R"({"a":1})");
-        json d = json::parse(R"([1,2,3,4,5])");
-        const auto c_start = c.start_pos();
-        const auto c_end = c.end_pos();
-        const auto d_start = d.start_pos();
-        const auto d_end = d.end_pos();
-
-        c.swap(d);
-
-        CHECK(c.start_pos() == d_start);
-        CHECK(c.end_pos() == d_end);
-        CHECK(d.start_pos() == c_start);
-        CHECK(d.end_pos() == c_end);
-    }
-}
-#endif
-
 // this test relies on parse errors being thrown, so it is skipped when
 // exceptions are disabled (json::parse aborts instead of throwing there)
 #if !defined(JSON_NOEXCEPTION)
@@ -326,57 +326,6 @@ TEST_CASE("lexicographical comparison operators")
 #endif
        }

-        SECTION("integer/float mixed comparison is exact")
-        {
-            // Widening the integer to a double loses precision past the
-            // mantissa, so 2^63-2 and 2^63-1 both used to compare equal to the
-            // double 2^63 while differing from each other. That makes equality
-            // intransitive and the ordering not a strict weak ordering.
-            const json below_two_63 = static_cast<std::int64_t>(9223372036854775806LL);
-            const json max_int64 = (std::numeric_limits<std::int64_t>::max)();
-            const json two_63 = 9223372036854775808.0;
-
-            CHECK_FALSE(below_two_63 == two_63);
-            CHECK_FALSE(max_int64 == two_63);
-            CHECK(below_two_63 != max_int64);
-            CHECK(below_two_63 < max_int64);
-            CHECK(below_two_63 < two_63);
-            CHECK(max_int64 < two_63);
-            CHECK(two_63 > max_int64);
-            CHECK_FALSE(two_63 < max_int64);
-
-            // the same past the unsigned range
-            const json max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
-            const json two_64 = 18446744073709551616.0;
-            CHECK_FALSE(max_uint64 == two_64);
-            CHECK(max_uint64 < two_64);
-            CHECK(two_64 > max_uint64);
-
-            // values a double represents exactly still compare equal
-            CHECK(json(1) == json(1.0));
-            CHECK(json(1u) == json(1.0));
-            CHECK(json(-3) == json(-3.0));
-            CHECK(json(1) < json(1.5));
-            CHECK(json(1.5) < json(2));
-            CHECK(json(2) > json(1.5));
-
-            // a NaN operand stays unordered against either integer kind
-            CHECK_FALSE(json(1) == json(nan));
-            CHECK_FALSE(json(1) < json(nan));
-            CHECK_FALSE(json(nan) < json(1));
-            CHECK_FALSE(json(1u) == json(nan));
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
-            CHECK((max_int64 <=> two_63) == std::partial_ordering::less); // *NOPAD*
-            CHECK((two_63 <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((below_two_63 <=> max_int64) == std::partial_ordering::less); // *NOPAD*
-            CHECK((max_uint64 <=> two_64) == std::partial_ordering::less); // *NOPAD*
-            CHECK((json(1) <=> json(1.0)) == std::partial_ordering::equivalent); // *NOPAD*
-            CHECK((json(1) <=> json(nan)) == std::partial_ordering::unordered); // *NOPAD*
-#endif
-        }
-
        SECTION("compares unordered")
        {
            std::vector<std::vector<bool>> expected =
@@ -98,10 +98,8 @@ void check_escaped(const char* original, const char* escaped = "", bool ensure_a
 void check_escaped(const char* original, const char* escaped, const bool ensure_ascii)
 {
    std::stringstream ss;
-    nlohmann::detail::output_stream_adapter<char> adapter(ss);
-    json::serializer s(adapter, ' ', false, ensure_ascii);
-    s.dump_escaped(original);
-    s.flush(); // dump_escaped writes into the serializer's internal buffer
+    json::serializer s(nlohmann::detail::output_adapter<char>(ss), ' ');
+    s.dump_escaped(original, ensure_ascii);
    CHECK(ss.str() == escaped);
 }
 } // namespace
@@ -1389,37 +1389,6 @@ TEST_CASE("value conversion")
                // CHECK(m5["one"] == "eins");
            }

-            SECTION("reserve is called on containers that support it (#5406)")
-            {
-                // build a larger object so that a missing/incorrect reserve()
-                // call would be more likely to corrupt or drop elements
-                json j_large;
-                for (int i = 0; i < 100; ++i)
-                {
-                    j_large[std::to_string(i)] = i;
-                }
-
-                SECTION("std::unordered_map (supports reserve)")
-                {
-                    const auto m = j_large.get<std::unordered_map<std::string, int>>();
-                    CHECK(m.size() == 100);
-                    for (int i = 0; i < 100; ++i)
-                    {
-                        CHECK(m.at(std::to_string(i)) == i);
-                    }
-                }
-
-                SECTION("std::map (no reserve, fallback path)")
-                {
-                    const auto m = j_large.get<std::map<std::string, int>>();
-                    CHECK(m.size() == 100);
-                    for (int i = 0; i < 100; ++i)
-                    {
-                        CHECK(m.at(std::to_string(i)) == i);
-                    }
-                }
-            }
-
            SECTION("std::multimap")
            {
                j1.get<std::multimap<std::string, int>>();
--- a/Show More
+++ b/Show More