Extend memcpy fast path to sized sentinels (e.g. std::counted_iterator)

Extend the memcpy fast path in iterator_input_adapter to sized sentinels of a different type, not just same-type iterator pairs. std::counted_iterator paired with std::default_sentinel_t already satisfies std::contiguous_iterator and std::sized_sentinel_for, so std::ranges::distance (C++20) lets that combination reach the fast path too, instead of silently falling back to the byte-by-byte path. - iterator_is_contiguous now also allows std::sized_sentinel_for<SentinelType, IteratorType> under C++20, gated the same way as the existing std::contiguous_iterator detection. - get_elements_impl's fast path uses std::ranges::distance under C++20 (works for both same-type and sized-sentinel pairs) and falls back to std::distance pre-C++20, where SentinelType is always IteratorType. - Add a C++20-only test exercising json::parse/accept with std::counted_iterator + std::default_sentinel_t. - Document std::default_sentinel_t + std::counted_iterator as a SentinelType example across parse.md, accept.md, sax_parse.md, and the five from_*.md pages, replacing an earlier ambiguously worded bullet. Addresses review feedback: https://github.com/nlohmann/json/pull/5265#discussion_r3564237584 Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Fix clang-tidy misc-const-correctness in heterogeneous sentinel test
2026-09-20 06:58:31 +00:00 · 2026-07-11 16:26:09 +02:00 · 2026-07-11 10:06:11 +02:00 · 2026-07-11 00:10:23 +02:00 · 2026-07-10 23:25:21 +02:00 · 2026-07-10 23:15:17 +02:00
154 changed files with 4643 additions and 17169 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.
+When fixing a bug, edit `unit-regression2.cpp` and add a section referencing the fixed issue.
 `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
 MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
 #### Exceptions
@@ -15,14 +15,6 @@ guidance.
 For vulnerabilities in third-party dependencies or modules, please report them directly to the respective maintainers.
 ## Unofficial packages
 This project does not publish an official npm package. The npm package
 [`nlohmann-json`](https://www.npmjs.com/package/nlohmann-json) (or similarly named packages) is not maintained or
 endorsed by this project. See the
 [package managers documentation](https://json.nlohmann.me/integration/package_managers/#npm) for supported
 integration options.
 ## Additional Resources
 - Explore security-related topics and contribute to tools and projects through
@@ -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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
@@ -34,19 +34,19 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: Checkout pull request
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          path: main
          ref: ${{ github.event.pull_request.head.sha }}
          persist-credentials: false
      - name: Checkout tools
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          path: tools
          ref: develop
@@ -67,18 +67,8 @@ jobs:
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp
          # fail loudly if a directory is renamed or removed: find would only warn
          # about the missing path and silently drop its files from the check
          SOURCE_DIRS="docs/mkdocs/docs/examples include tests"
          for DIR in $SOURCE_DIRS; do
            if [ ! -d "$DIR" ]; then
              echo "::error::source directory '$DIR' does not exist"
              exit 1
            fi
          done
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
-            $(find $SOURCE_DIRS -type f \( -name '*.hpp' -o -name '*.cpp' -o -name '*.cu' \) -not -path 'tests/thirdparty/*' -not -path 'tests/abi/include/nlohmann/*' | sort)
+            $(find docs/examples include tests -type f \( -name '*.hpp' -o -name '*.cpp' -o -name '*.cu' \) -not -path 'tests/thirdparty/*' -not -path 'tests/abi/include/nlohmann/*' | sort)
      - name: Build patch and check for differences
        id: diff
@@ -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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
      with:
        egress-policy: audit
@@ -27,25 +27,25 @@ jobs:
    steps:
    - name: Harden Runner
-      uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+      uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
      with:
        egress-policy: audit
    - name: Checkout repository
-      uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      with:
        persist-credentials: false
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
      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@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/autobuild@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
@@ -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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
@@ -17,12 +17,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: 'Checkout Repository'
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: 'Dependency Review'
@@ -27,12 +27,12 @@ jobs:
      security-events: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: Checkout code
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
@@ -43,6 +43,6 @@ jobs:
          output: 'flawfinder_results.sarif'
      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
@@ -26,7 +26,7 @@ jobs:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -45,7 +45,7 @@ jobs:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -62,7 +62,7 @@ jobs:
        standard: [11, 14, 17, 20, 23, 26]
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -7,6 +7,7 @@ on:
      - develop
    paths:
      - docs/mkdocs/**
      - docs/examples/**
  workflow_dispatch:
 # we don't want to have concurrent jobs, and we don't want to cancel running jobs to avoid broken publications
@@ -26,11 +27,11 @@ jobs:
    runs-on: ubuntu-22.04
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Install virtual environment
        run: make install_venv -C docs/mkdocs
@@ -36,17 +36,17 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: "Checkout code"
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: "Run analysis"
-        uses: ossf/scorecard-action@2d1146689b8cda280b9bc96326124645441f03bc # v2.4.4
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
        with:
          results_file: results.sarif
          results_format: sarif
@@ -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@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        with:
          sarif_file: results.sarif
@@ -32,12 +32,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      # Checkout project source
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
@@ -61,7 +61,7 @@ jobs:
      # Upload SARIF file generated in previous step
      - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -16,11 +16,11 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
-      - uses: actions/stale@4391f3da665fdf50b6810c1a66712fb9ba21aa93 # v11.0.0
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
        with:
          stale-issue-label: 'state: stale'
          stale-pr-label: 'state: stale'
@@ -21,11 +21,11 @@ jobs:
    runs-on: ubuntu-latest
    container: gcc:latest
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
@@ -43,11 +43,11 @@ jobs:
        run: |
          wget -q -O - "https://github.com/facebook/infer/releases/download/v1.3.0/infer-linux-x86_64-v1.3.0.tar.xz" | sudo tar -C /opt -xJ
          sudo ln -s /opt/infer-linux-x86_64-v1.3.0/bin/infer /usr/local/bin/infer
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -60,17 +60,17 @@ 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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: Install Valgrind
        run: sudo apt-get update ; sudo apt-get install -y valgrind
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -85,11 +85,11 @@ jobs:
    steps:
      - name: Install git, clang-tools, iwyu (ci_single_binaries), and unzip
        run: apt-get update ; apt-get install -y git clang-tools iwyu unzip
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -100,15 +100,15 @@ 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
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -118,11 +118,11 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Install dependencies and de_DE locale
@@ -142,7 +142,7 @@ jobs:
          name: code-coverage-report
          path: ${{ github.workspace }}/build/html
      - name: Publish report to Coveralls
-        uses: coverallsapp/github-action@8d6379e14d29928660c4ba802d8e85393440b329 # v2.3.8
+        uses: coverallsapp/github-action@5cbfd81b66ca5d10c19b062c04de0199c215fb6e # v2.3.7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          path-to-lcov: ${{ github.workspace }}/build/json.info.filtered.noexcept
@@ -163,15 +163,7 @@ jobs:
          export DEBIAN_FRONTEND=noninteractive
          apt-get update
          apt-get install -y --no-install-recommends software-properties-common ca-certificates gnupg make git
-          # add-apt-repository resolves the PPA through the Launchpad API,
+          add-apt-repository -y ppa:ubuntu-toolchain-r/test
          # which intermittently times out or fails the team lookup (the plain
          # "deb ..." sources below never hit Launchpad and never flake).
          # Retry with backoff so a transient Launchpad blip does not fail CI.
          for attempt in 1 2 3 4 5; do
            add-apt-repository -y ppa:ubuntu-toolchain-r/test && break
            echo "::warning::add-apt-repository ppa:ubuntu-toolchain-r/test failed (attempt ${attempt}/5); retrying"
            sleep $((attempt * 10))
          done
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic main"
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic universe"
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial main"
@@ -180,11 +172,11 @@ jobs:
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial-updates universe"
          apt-get update
          apt-get install -y --no-install-recommends g++-${{ matrix.compiler }}
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: CXX=g++-${{ matrix.compiler }} cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -198,11 +190,11 @@ jobs:
        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
    container: gcc:${{ matrix.compiler }}
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -212,14 +204,14 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        compiler: ['3.4', '3.5', '3.6', '3.7', '3.8', '3.9', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15-bullseye', '16', '17', '18', '19', '20', '21', '22', 'latest']
+        compiler: ['3.4', '3.5', '3.6', '3.7', '3.8', '3.9', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15-bullseye', '16', '17', '18', '19', '20', 'latest']
    container: silkeh/clang:${{ matrix.compiler }}
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Set env FORCE_STDCPPFS_FLAG for clang 7 / 8 / 9 / 10
        run: echo "JSON_FORCED_GLOBAL_COMPILE_OPTIONS=-DJSON_HAS_FILESYSTEM=0;-DJSON_HAS_EXPERIMENTAL_FILESYSTEM=0" >> "$GITHUB_ENV"
        if: ${{ matrix.compiler == '7' || matrix.compiler == '8' || matrix.compiler == '9' || matrix.compiler == '10' }}
@@ -235,11 +227,11 @@ jobs:
      matrix:
        standard: [11, 14, 17, 20, 23, 26]
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -255,11 +247,11 @@ jobs:
    steps:
      - name: Install git and unzip
        run: apt-get update ; apt-get install -y git unzip
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build with libc++
@@ -282,11 +274,11 @@ jobs:
        cuda: ['11.8.0', '12.1.1', '12.6.3']
    container: nvidia/cuda:${{ matrix.cuda }}-devel-ubuntu22.04
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -299,14 +291,14 @@ jobs:
    runs-on: ubuntu-latest
    container: ${{ matrix.container }}
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      # The module test uses `import std;`, which needs CMake's experimental
      # import-std support. Its opt-in token is CMake-version-specific, so pin
      # CMake to the version whose token is set in tests/module_cpp20/CMakeLists.txt.
      - name: Get pinned CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
        with:
          cmakeVersion: 4.3.4
      # Clang: the std library module is provided by libc++ (the image's libstdc++
@@ -328,11 +320,11 @@ jobs:
    # Intel's own last officially published image that still includes it.
    container: intel/oneapi-hpckit:2023.2.1-devel-ubuntu22.04
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -345,9 +337,9 @@ jobs:
    runs-on: ubuntu-latest
    container: intel/oneapi-hpckit:latest
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -357,9 +349,9 @@ jobs:
    runs-on: ubuntu-latest
    container: nvcr.io/nvidia/nvhpc:25.5-devel-cuda12.9-ubuntu22.04
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -369,17 +361,17 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
      - name: Install emscripten
        uses: mymindstorm/setup-emsdk@4528d102f7230f0e7b276855c01ea1159be0e984 # v16
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -GNinja
      - name: Build
@@ -392,11 +384,11 @@ 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@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -24,7 +24,7 @@ jobs:
        architecture: [x64, x86]
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Set up MinGW
@@ -49,7 +49,7 @@ jobs:
    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Set extra CXX_FLAGS for latest std_version
@@ -86,9 +86,9 @@ jobs:
    runs-on: windows-2025
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Set extra CXX_FLAGS for latest std_version
        # /wd5285 silences C5285 emitted by the bundled third-party doctest.h, which
        # specializes std::tuple (newly diagnosed by the VS2026 v145 toolset)
@@ -122,7 +122,7 @@ jobs:
    runs-on: windows-11-arm
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Run CMake (Release)
        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
        if: matrix.build_type == 'Release'
@@ -143,7 +143,7 @@ jobs:
        version: [11.0.1, 12.0.1, 13.0.1, 14.0.6, 15.0.7, 16.0.6, 18.1.8, 19.1.7, 20.1.8]
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Install Clang
@@ -153,16 +153,10 @@ jobs:
        with:
          platform: x64
          version: 12.2.0 # https://github.com/egor-tensin/setup-mingw/issues/14
      # CMAKE_CXX_FLAGS_DEBUG is overridden to drop the default -g: linking
      # test-regression2_cpp20 intermittently fails with "relocation truncated
      # to fit: IMAGE_REL_AMD64_SECREL against `.debug_line'" because the
      # MinGW linker cannot relocate the debug sections this test produces.
      # The tests are only built and run here, so the debug info is not used.
      - name: Run CMake
        run: cmake -S . -B build ^
             -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^
             -DCMAKE_CXX_FLAGS="--target=x86_64-w64-mingw32 -stdlib=libstdc++ -pthread" ^
             -DCMAKE_CXX_FLAGS_DEBUG="-g0" ^
             -DCMAKE_EXE_LINKER_FLAGS="-lwinpthread" ^
             -G"MinGW Makefiles" ^
             -DCMAKE_BUILD_TYPE=Debug ^
@@ -179,7 +173,7 @@ jobs:
        architecture: [Win32, x64]
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -192,14 +186,14 @@ jobs:
  ci_module_cpp20:
    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      # The module test uses `import std;`, which needs CMake's experimental
      # import-std support. Its opt-in token is CMake-version-specific, so pin
      # CMake to the version whose token is set in tests/module_cpp20/CMakeLists.txt.
      - name: Get pinned CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
        with:
          cmakeVersion: 4.3.4
      - name: Run CMake (Debug)
@@ -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
 ##########################################################################
@@ -42,7 +42,6 @@
  - [Specializing enum conversion](#specializing-enum-conversion)
  - [Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)](#binary-formats-bson-cbor-messagepack-ubjson-and-bjdata)
 - [Customers](#customers)
 - [Ecosystem](#ecosystem)
 - [Supported compilers](#supported-compilers)
 - [Integration](#integration)
  - [CMake](#cmake)
@@ -91,6 +90,7 @@ You can sponsor this library at [GitHub Sponsors](https://github.com/sponsors/nl
 - [Steve Sperandeo](https://github.com/homer6)
 - [Robert Jefe Lindstädt](https://github.com/eljefedelrodeodeljefe)
 - [Steve Wagner](https://github.com/ciroque)
 - [Lion Yang](https://github.com/LionNatsu)
 ### Further support
@@ -1187,11 +1187,6 @@ The library is used in multiple projects, applications, operating systems, etc.
 [![logos of customers using the library](docs/mkdocs/docs/images/customers.png)](https://json.nlohmann.me/home/customers/)
 ## Ecosystem
 Beyond projects that use the library, there are third-party projects that build on top of it - schema validators,
 language bindings, format converters, and the like. See the curated [Ecosystem](https://json.nlohmann.me/community/ecosystem/) page.
 ## Supported compilers
 Though it's 2026 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:
@@ -1807,13 +1802,13 @@ The library itself consists of a single header file licensed under the MIT licen
 - [**amalgamate.py - Amalgamate C source and header files**](https://github.com/edlund/amalgamate) to create a single header file
 - [**American fuzzy lop**](https://lcamtuf.coredump.cx/afl/) for fuzz testing
 - [**AppVeyor**](https://www.appveyor.com) for [continuous integration](https://ci.appveyor.com/project/nlohmann/json) on Windows
- [**Artistic Style**](https://astyle.sourceforge.net) for automatic source code indentation
+- [**Artistic Style**](http://astyle.sourceforge.net) for automatic source code indentation
 - [**Clang**](https://clang.llvm.org) for compilation with code sanitizers
 - [**CMake**](https://cmake.org) for build automation
 - [**Codacy**](https://www.codacy.com) for further [code analysis](https://app.codacy.com/gh/nlohmann/json/dashboard)
 - [**Coveralls**](https://coveralls.io) to measure [code coverage](https://coveralls.io/github/nlohmann/json)
 - [**Coverity Scan**](https://scan.coverity.com) for [static analysis](https://scan.coverity.com/projects/nlohmann-json)
- [**cppcheck**](https://cppcheck.sourceforge.io) for static analysis
+- [**cppcheck**](http://cppcheck.sourceforge.net) for static analysis
 - [**doctest**](https://github.com/onqtam/doctest) for the unit tests
 - [**GitHub Changelog Generator**](https://github.com/skywinder/github-changelog-generator) to generate the [ChangeLog](https://github.com/nlohmann/json/blob/develop/ChangeLog.md)
 - [**Google Benchmark**](https://github.com/google/benchmark) to implement the benchmarks
@@ -1828,15 +1823,6 @@ The library itself consists of a single header file licensed under the MIT licen
 ## Notes
 ### Standards compliance
 The library targets strict conformance with [RFC 8259](https://tools.ietf.org/html/rfc8259.html). Both the original [JSONTestSuite](https://github.com/nst/JSONTestSuite) and its updated revision are exercised in CI; their test data is downloaded from [`nlohmann/json_test_data`](https://github.com/nlohmann/json_test_data) at configure time rather than committed to this repository (see [`tests/src/unit-testsuites.cpp`](https://github.com/nlohmann/json/blob/develop/tests/src/unit-testsuites.cpp)):
 - The updated revision runs all mandatory `y_` (must-accept) and `n_` (must-reject) cases through the strict [`parse()`](https://json.nlohmann.me/api/basic_json/parse/) entry point; the original suite runs its `n_` cases through `parse()` and its `y_` cases through [`operator>>`](https://json.nlohmann.me/api/operator_gtgt/).
 - The `i_` (implementation-defined) cases are, by RFC 8259, free to be accepted *or* rejected, so "passing all `i_` cases" is not a meaningful conformance metric. The library makes deliberate, documented choices there: nesting depth is not artificially limited, a leading UTF-8 byte order mark is silently ignored, [Unicode noncharacters](https://www.unicode.org/faq/private_use.html#nonchar1) are forwarded unchanged, invalid UTF-8 and lone/unpaired UTF-16 surrogates are rejected (stricter than required), and a number that cannot be stored without becoming `NaN`/`INF` raises [`out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406).
 One behavioral nuance is worth calling out, because a superficial test often misreads it as non-compliance: [`parse()`](https://json.nlohmann.me/api/basic_json/parse/) is strict and rejects trailing data after a value, whereas [`operator>>`](https://json.nlohmann.me/api/operator_gtgt/) follows relaxed iostream semantics — it parses a single value and leaves the stream positioned right after it. Feeding "a valid document followed by trailing bytes" through `operator>>` reports success; the same input through `parse()` is rejected. This is a documented two-API design, not a conformance gap. See [**parsing**](https://json.nlohmann.me/features/parsing/) for details.
 ### Character encoding
 The library supports **Unicode input** as follows:
@@ -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.
 ###############################################################################
@@ -312,7 +294,7 @@ file(GLOB_RECURSE INDENT_FILES
        ${PROJECT_SOURCE_DIR}/tests/src/*.cpp
        ${PROJECT_SOURCE_DIR}/tests/src/*.hpp
        ${PROJECT_SOURCE_DIR}/tests/benchmarks/src/benchmarks.cpp
-    ${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cpp
+    ${PROJECT_SOURCE_DIR}/docs/examples/*.cpp
 )
 set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
@@ -5,9 +5,6 @@
 # -Wno-extra-semi-stmt            The library uses assert which triggers this warning.
 # -Wno-padded                     We do not care about padding warnings.
 # -Wno-covered-switch-default     All switches list all cases and a default case.
 # -Wno-c2y-extensions             Clang 22.1 diagnoses __COUNTER__ as a C2y extension, also in
 #                                 C++ mode. The library does not use __COUNTER__; the warnings
 #                                 all come from vendored Doctest (SECTION/TEST_CASE macros).
 # -Wno-unsafe-buffer-usage        Pervasive: the library's own low-level numeric/buffer code
 #                                 (to_chars, serializer, lexer, binary reader/writer, input
 #                                 adapters, json_pointer) plus vendored Doctest itself (~208
@@ -23,6 +20,5 @@ set(CLANG_CXXFLAGS
    -Wno-extra-semi-stmt
    -Wno-padded
    -Wno-covered-switch-default
    -Wno-c2y-extensions
    -Wno-unsafe-buffer-usage
 )
@@ -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
+:   container type to store arrays (e.g., `std::vector` or `std::list`)
    `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.
 `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.
@@ -13,8 +13,9 @@ is compatible with both of the binary data formats that use binary subtyping, (t
 incompatible with each other, and it is up to the user to translate between them). The subtype is added to `BinaryType`
 via the helper type [byte_container_with_subtype](../byte_container_with_subtype/index.md).
-[CBOR's RFC 8949](https://www.rfc-editor.org/rfc/rfc8949.html#section-3.1) describes this type as:
+[CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type as:
-> Major type 2: A byte string. The number of bytes in the string is equal to the argument.
+> Major type 2: a byte string. The string's length in bytes is represented following the rules for positive integers
 > (major type 0).
 [MessagePack's documentation on the bin type
 family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family) describes this type as:
@@ -42,9 +43,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
+    `#!cpp std::vector<std::intptr_t>` will not work as `BinaryType`.
    the binary readers additionally require `resize()` and `operator[]`. See
    [Template Parameter Requirements](../../features/types/template_parameters.md#binarytype) for the full list.
 ## Notes
@@ -52,43 +51,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
 values of that type directly to a `basic_json` instance, and they will automatically be recognized as binary values
 rather than arrays:
 ```cpp
 using custom_json = nlohmann::basic_json<
    nlohmann::ordered_map,  // ObjectType
    std::vector,            // ArrayType
    std::string,            // StringType
    bool,                   // BooleanType
    std::int64_t,           // NumberIntegerType
    std::uint64_t,          // NumberUnsignedType
    double,                 // NumberFloatType
    std::allocator,         // AllocatorType
    nlohmann::adl_serializer,
    std::vector<std::byte>  // Custom BinaryType
 >;
 std::vector<std::byte> data{std::byte{1}, std::byte{2}, std::byte{3}};
 custom_json j = data;  // Creates a binary value, not an array
 assert(j.is_binary());
 // Round-tripping works seamlessly
 auto extracted = j.get<std::vector<std::byte>>();
 assert(extracted == data);
 ```
 This automatic type detection is a convenience feature that only applies to custom (non-default) `BinaryType` configurations.
 The default `nlohmann::json` continues to treat `#!cpp std::vector<std::uint8_t>` as arrays for backward compatibility.
 #### Storage
 Binary Arrays are stored as pointers in a `basic_json` type. That is, for any access to array values, a pointer of the
@@ -133,6 +95,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
@@ -43,17 +43,6 @@ Strong guarantee: if an exception is thrown, there are no changes to any JSON va
 Throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if a string stored inside the JSON value
 is not UTF-8 encoded and `error_handler` is set to `strict`
 !!! warning "Serializing untrusted input"
    When serializing values that may contain invalid or untrusted UTF-8 (e.g., bytes taken directly from network
    input), `dump()` throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) in the default
    `strict` mode. To serialize such data without throwing, pass
    [`error_handler_t::replace`](error_handler_t.md) (substitutes U+FFFD) or
    [`error_handler_t::ignore`](error_handler_t.md). Callers that serialize untrusted input on a crash-sensitive path
    should either choose a non-strict error handler or wrap `dump()` in a `#!cpp try`/`#!cpp catch`.
    See the [FAQ](../../home/faq.md#serializing-untrusted-or-invalid-utf-8) for details.
 ## Complexity
 Linear.
@@ -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
+:   the container to store objects (e.g., `std::map` or `std::unordered_map`)
    `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.
 `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.
@@ -29,14 +29,7 @@ Discarding a value (i.e., returning `#!cpp false`) has different effects dependi
 called:
 - Discarded values in structured types are skipped. That is, the parser will behave as if the discarded value was never
-  read. This holds for every value type and for both kinds of parent: a discarded element is removed from the
+  read.
  surrounding array, and a discarded member is removed from the surrounding object together with its key.
 - Arrays and objects can be discarded either at their `parse_event_t::array_start`/`parse_event_t::object_start` event
  or at their `parse_event_t::array_end`/`parse_event_t::object_end` event, and both remove the whole value. Discarding
  it at the start event also means the callback is called neither for the content of the value nor for its matching end
  event.
 - Discarding a `parse_event_t::key` event discards the whole object member. The callback is still called for the
  associated value, but its return value has no further effect.
 - In case a value outside a structured type is skipped, it is replaced with `null`. This case happens if the top-level
  element is skipped.
@@ -56,7 +49,7 @@ called:
 ## Return value
 Whether the JSON value which called the function during parsing should be kept (`#!cpp true`) or not (`#!cpp false`). In
-the latter case, it is skipped completely, or replaced by `null` if it is the top-level value.
+the latter case, it is either skipped completely or replaced by an empty discarded object.
 ## Examples
@@ -75,21 +68,6 @@ the latter case, it is skipped completely, or replaced by `null` if it is the to
    --8<-- "examples/parse__string__parser_callback_t.output"
    ```
 ??? example
    The example below shows where discarded values are removed. The array and the number are discarded in different
    ways, but in each case the parse result contains neither the value nor its key.
    ```cpp
    --8<-- "examples/parser_callback_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parser_callback_t.output"
    ```
 ## See also
 - [parse](parse.md) deserialize from a compatible input
@@ -98,5 +76,3 @@ the latter case, it is skipped completely, or replaced by `null` if it is the to
 ## Version history
 - Added in version 1.0.0.
 - Fixed in version 3.13.0 to also remove discarded values from a parent object; before, discarding an array or a value
  stored under an object key left a discarded member behind, which made the parse result serialize to invalid JSON.
@@ -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
+   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. 
   [`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.
 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
+   invalidated. Implemented as a friend function callable via ADL.
   [`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.
 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
@@ -52,11 +52,6 @@ optional, `#!cpp bjdata_version_t::draft2` by default.
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 ## Exceptions
 - Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
  is false.
 ## Complexity
 Linear in the size of the JSON value `j`.
@@ -40,15 +40,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  is not an object; example: `"to serialize to BSON, top-level type must be object, but is string"`
 - Throws [`out_of_range.409`](../../home/exceptions.md#jsonexceptionout_of_range409) if a key in the JSON object contains
  a null byte (code point U+0000); example: `"BSON key cannot contain code point U+0000 (at byte 2)"`
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
  string, or binary value exceeds the range of the 32-bit BSON length field; example:
  `"BSON length 2147483661 exceeds maximum of 2147483647"`
 ## Complexity
-Proportional to the size of the JSON value `j` multiplied by its maximum nesting
+Linear in the size of the JSON value `j`.
 depth, `O(n × d)`. BSON length prefixes are computed recursively before nested
 values are written.
 ## Examples
@@ -45,11 +45,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 ## Exceptions
 - Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
  is false.
 ## Complexity
 Linear in the size of the JSON value `j`.
@@ -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.
+their original type. Apart from this example, for a JSON value `j`, the following is always true:
 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:
 `#!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
@@ -38,8 +38,7 @@ When the macro is not defined, the library will define it to its default value.
    Diagnostic messages can also be controlled with the CMake option
    [`JSON_Diagnostics`](../../integration/cmake.md#json_diagnostics) (`OFF` by default)
-    which defines `JSON_DIAGNOSTICS` accordingly. Note this only applies when building the
+    which defines `JSON_DIAGNOSTICS` accordingly.
    library from source — see the pre-installed-package caveat on that page.
 ## Examples
@@ -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
+   The argument is the type of the exception to catch. As of version 3.8.0, the library only catches `std::out_of_range`
-   escaping the parent-pointer check that [`JSON_DIAGNOSTICS`](json_diagnostics.md) adds to the class invariant. The
+   exceptions internally to rethrow them as [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions.
-   places where the library catches its own [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions
+   The macro is always followed by a scope.
   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.
 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.
@@ -33,44 +33,17 @@ A UTF-8 byte order mark is silently ignored.
 Invalid Unicode escapes and unpaired surrogates in the input are reported as
 [`parse_error.101`](../home/exceptions.md#jsonexceptionparse_error101) with a detailed message.
-`operator>>` parses exactly one JSON value, so it can be called repeatedly to read a sequence of concatenated JSON
+`operator>>` parses exactly one JSON value and leaves the stream positioned right after it, so it can be called
-values from the same stream:
+repeatedly to read a sequence of concatenated JSON values from the same stream:
 ```cpp
 json j1, j2;
-input >> j1;  // parses the first value
+input >> j1;  // parses the first value, stream now positioned right after it
 input >> j2;  // parses the next value
 ```
-!!! warning "A number must be followed by whitespace"
+Note this does **not** work for [JSON Lines](../features/parsing/json_lines.md) (newline-delimited JSON) input --
-
+see that page for why and for the recommended alternative.
    A number is only terminated by the character that follows it. That character is read from the stream to detect the
    end of the number, and it is **not** put back. When a value that is a number is immediately followed by the next
    value, the first character of that next value is lost:
    ```cpp
    std::istringstream input("1true");
    json j1, j2;
    input >> j1;  // j1 == 1
    input >> j2;  // throws parse_error.101: the stream now starts at "rue"
    ```
    Separating the values with whitespace avoids this, because the character that is eaten is then the separator:
    ```cpp
    std::istringstream input("1 true");
    json j1, j2;
    input >> j1;  // j1 == 1
    input >> j2;  // j2 == true
    ```
    Only numbers are affected. Values ending in a self-delimiting character do not read past themselves, so
    `truefalse`, `[1][2]`, `{"a":1}{"b":2}`, and `"a""b"` can be read back to back without a separator.
    This is tracked in [#5340](https://github.com/nlohmann/json/issues/5340).
 Note that reading concatenated values does **not** work for [JSON Lines](../features/parsing/json_lines.md)
 (newline-delimited JSON) input -- see that page for why and for the recommended alternative.
 !!! warning "Deprecation"
@@ -13,12 +13,6 @@ Therefore, adding object elements can yield a reallocation in which case all ite
 [`end()`](basic_json/end.md) iterator) and all references to the elements are invalidated. Also, any iterator or
 reference after the insertion point will point to the same index, which is now a different value.
 ## Complexity
 [`ordered_map`](ordered_map.md) has no lookup index: every key-based object operation is a linear scan, so building or
 parsing an object of `n` keys costs O(n²) rather than O(n log n). See
 [`ordered_map` complexity](ordered_map.md#complexity) for the per-operation table and for measured numbers.
 ## Examples
 ??? example
@@ -56,48 +56,6 @@ std::equal_to<>     // since C++14
 - **find**
 - **insert**
 ## Complexity
 Because the elements are stored in a `std::vector` in insertion order, there is no index to look a key up by. Every
 key-based operation performs a **linear scan** over the stored elements. With `n` denoting the number of elements in the
 container:
 | Operation                              | Complexity     | Note                                                     |
 |----------------------------------------|----------------|----------------------------------------------------------|
 | **emplace**                            | O(n)           | scans for an existing key, then appends (amortized O(1)) |
 | **operator\[\]**                       | O(n)           | delegates to **emplace** (non-const) or **at** (const)   |
 | **at**                                 | O(n)           | throws `#!cpp std::out_of_range` if the key is not found |
 | **find**                               | O(n)           |                                                          |
 | **count**                              | O(n)           | the result is always 0 or 1                              |
 | **erase(key)**                         | O(n)           | scan, then move the remaining elements one position down |
 | **erase(pos)**, **erase(first, last)** | O(n)           | moves all elements after the erased range                |
 | **insert(value)**                      | O(n)           | equivalent to **emplace**                                |
 | **insert(first, last)**                | O((n + m) * m) | for `m` inserted elements                                |
 This differs from `#!cpp std::map`, where the same operations are O(log n).
 !!! warning "Quadratic cost of building large objects"
    Because every insertion scans all elements inserted so far, building an object of `n` distinct keys costs
    **O(n²)** in total. This applies to filling an [`ordered_json`](ordered_json.md) object key by key as well as to
    parsing one, since the parser inserts each key as it is read.
    The cost is negligible for the object sizes typically found in configuration files or API payloads, but it grows
    steeply for machine-generated objects with many thousands of keys. Measured with `-O2 -DNDEBUG` for parsing a flat
    object of `n` keys, relative to `#!cpp nlohmann::json` (which uses `#!cpp std::map`):
    | `n`    | `json` | `ordered_json` | factor |
    |--------|--------|----------------|--------|
    | 2000   | 0.7 ms | 3.6 ms         | 5×     |
    | 4000   | 0.8 ms | 14.0 ms        | 19×    |
    | 8000   | 1.6 ms | 67.8 ms        | 43×    |
    | 16 000 | 3.3 ms | 181.6 ms       | 54×    |
    If key order matters for objects of that size, consider a container with a lookup index, such as
    [`tsl::ordered_map`](https://github.com/Tessil/ordered-map)
    ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)), as the object type -- see
    [object order](../features/object_order.md).
 ## Examples
 ??? example
@@ -1,40 +0,0 @@
 # Ecosystem
 The projects below build on top of `nlohmann::json` rather than merely using it - schema validators, language
 bindings, format converters, and similar building blocks. The list is not exhaustive, and is curated rather than
 automatically generated. If you maintain or know of a project that belongs here,
 [please let me know](mailto:mail@nlohmann.me).
 For products, applications, and organizations that use the library, see [Customers](../home/customers.md) instead.
 ## Schema validation
 - [**json-schema-validator**](https://github.com/pboettch/json-schema-validator), a JSON Schema (draft 7) validator
  with human-readable error messages
 ## Serialization and reflection
 - [**nlohmann_json_reflect**](https://github.com/1261385937/nlohmann_json_reflect), a reflection extension for
  (de)serializing nested containers-in-structs-in-containers
 ## Encodings
 - [**base-encode-decode**](https://github.com/saxonnicholls/base-encode-decode), a header-only Base64/32/16/8/4/2
  (and DNA/RNA) encoding library, with an adapter that serializes binary data through `nlohmann::json`
 ## Language bindings and interop
 - [**pybind11_json**](https://github.com/pybind/pybind11_json), a bidirectional type caster between
  `nlohmann::json` and Python objects for [pybind11](https://github.com/pybind/pybind11) bindings
 - [**nanobind_json**](https://github.com/ianhbell/nanobind_json), the same idea for
  [nanobind](https://github.com/wjakob/nanobind) bindings
 - [**nlohmann_json_qt**](https://github.com/dpurgin/nlohmann_json_qt), deserialization helpers for Qt types
  (`QString`, `QUrl`, `QDateTime`, `QVector`, ...) from `nlohmann::json`
 - [**vulkan2json**](https://github.com/Fadis/vulkan2json), serialization and deserialization of Vulkan API structs
 ## Format converters
 - [**tojson**](https://github.com/mircodz/tojson), a header-only converter between YAML/XML documents and
  `nlohmann::json`
 - [**json2xml**](https://github.com/testillano/json2xml), a header-only converter from `nlohmann::json` to XML for
  simple configuration documents
@@ -1,6 +1,5 @@
 # Community
 - [Ecosystem](ecosystem.md) - third-party projects built on top of this library
 - [Code of Conduct](code_of_conduct.md) - the rules and norms of this project
 - [Contribution Guidelines](contribution_guidelines.md) - guidelines how to contribute to this project
 - [Governance](governance.md) - the governance model of this project
@@ -66,7 +66,6 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | Clang 20.1.1                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 20.1.8 with GNU-like command-line      | x86_64       | Windows Server 2022 (Build 20348) | GitHub    |
        | Clang 21.1.8                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 22.1.8                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | CUDA 11.8.0 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | CUDA 12.1.1 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | CUDA 12.6.3 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
@@ -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
@@ -1,47 +0,0 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 int main()
 {
    // a JSON text with an array and a number inside an object
    auto text = R"({"IDs": [116, 943], "Width": 800})";
    // discard the array when the parser reads its opening bracket
    json j_array_start = json::parse(text, [](int /*depth*/, json::parse_event_t event, json& /*parsed*/)
    {
        return event != json::parse_event_t::array_start;
    });
    // discard the same array when the parser reads its closing bracket
    json j_array_end = json::parse(text, [](int /*depth*/, json::parse_event_t event, json& /*parsed*/)
    {
        return event != json::parse_event_t::array_end;
    });
    // discard the number, but keep its key
    json j_value = json::parse(text, [](int /*depth*/, json::parse_event_t event, json & parsed)
    {
        return !(event == json::parse_event_t::value && parsed == json(800));
    });
    // discard the key of the number
    json j_key = json::parse(text, [](int /*depth*/, json::parse_event_t event, json & parsed)
    {
        return !(event == json::parse_event_t::key && parsed == json("Width"));
    });
    // discard the top-level object
    json j_root = json::parse(text, [](int /*depth*/, json::parse_event_t event, json& /*parsed*/)
    {
        return event != json::parse_event_t::object_end;
    });
    // in every case, the discarded value is removed together with its key
    std::cout << j_array_start << '\n'
              << j_array_end << '\n'
              << j_value << '\n'
              << j_key << '\n'
              << j_root << '\n';
 }
@@ -1,5 +0,0 @@
 {"Width":800}
 {"Width":800}
 {"IDs":[116,943]}
 {"IDs":[116,943]}
 null
@@ -116,20 +116,9 @@ The library uses the following mapping from JSON values types to BJData types ac
    ```
    Likewise, when a JSON object in the above form is serialized using
-    [`to_bjdata`](../../api/basic_json/to_bjdata.md), it is automatically converted into a compact BJData ND-array. When
+    [`to_bjdata`](../../api/basic_json/to_bjdata.md), it is automatically converted into a compact BJData ND-array. The
-    the 1-dimensional vector stored in `"_ArraySize_"` contains a single integer or two integers with one being 1, a
+    only exception is, that when the 1-dimensional vector stored in `"_ArraySize_"` contains a single integer or two
-    regular 1-D optimized array is generated instead.
+    integers with one being 1, a regular 1-D optimized array is generated.
    An object is only converted if the annotation actually describes a packed array; otherwise it is serialized as a
    regular JSON object. This requires all of the following:
    - `"_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
      `single` and `double`, an integer otherwise).
    The current version of this library does not yet support automatic detection of and conversion from a nested JSON
    array input to a BJData ND-array.
@@ -35,19 +35,6 @@ The library uses the following mapping from JSON values types to BSON types:
    The mapping is **incomplete**, since only JSON-objects (and things contained therein) can be serialized to BSON.
    Also, keys may not contain U+0000, since they are serialized a zero-terminated c-strings.
 !!! warning "BSON type 0x11 interoperability"
    The BSON specification defines type `0x11` as a Timestamp. This library uses marker `0x11` when serializing
    `number_unsigned` values in the range `9223372036854775808..18446744073709551615`. Other BSON implementations may
    therefore interpret these values as Timestamps instead of unsigned integers.
 !!! info "Binary values without a subtype"
    BSON requires every binary value to have a subtype. If a binary value has no subtype, this library serializes it
    with the generic subtype `0x00`. After deserialization, `has_subtype()` returns `true` and `subtype()` returns `0`.
    As a result, serializing and deserializing a JSON object containing such a value produces a different JSON object,
    even though the binary data is unchanged.
 ??? example
    ```cpp
@@ -95,19 +82,8 @@ The library maps BSON record types to JSON value types as follows:
 !!! note "Handling of BSON type 0x11"
-    This library deserializes BSON type `0x11` (Timestamp) as a `number_unsigned` value. The 64-bit value is preserved,
+    BSON type 0x11 is used to represent uint64 numbers. This library treats these values purely as uint64 numbers 
-    but the Timestamp type information is not.
+    and does not parse them into date-related formats.
 !!! warning "Lenient BSON input handling"
    The BSON reader is lenient in a few areas where the BSON specification is more restrictive:
    - array element keys are not checked against the required decimal sequence (`0`, `1`, `2`, ...),
    - any non-zero byte is accepted as `true` for the boolean type, and
    - the payload for binary subtype `0x02` is returned as-is, including its inner length prefix.
    If BSON input must be validated for strict specification compliance, validate it separately before passing it to
    `from_bson()`.
 ??? example
@@ -7,12 +7,12 @@ extremely small code sizes, fairly small message size, and extensibility without
    - [CBOR Website](http://cbor.io) - the main source on CBOR
    - [CBOR Playground](http://cbor.me) - an interactive webpage to translate between JSON and CBOR
-    - [RFC 8949](https://www.rfc-editor.org/rfc/rfc8949.html) - the CBOR specification
+    - [RFC 7049](https://tools.ietf.org/html/rfc7049) - the CBOR specification
 ## Serialization
 The library uses the following mapping from JSON values types to CBOR types according to the CBOR specification
-([RFC 8949](https://www.rfc-editor.org/rfc/rfc8949.html)):
+([RFC 7049](https://www.rfc-editor.org/rfc/rfc7049.html)):
 | JSON value type | value/range                                | CBOR type                         | first byte |
 |-----------------|--------------------------------------------|-----------------------------------|------------|
@@ -160,11 +160,14 @@ The library maps CBOR types to JSON value types as follows:
    The mapping is **incomplete** in the sense that not all CBOR types can be converted to a JSON value. The following CBOR types are not supported and will yield parse errors:
     - date/time (0xC0..0xC1)
     - bignum (0xC2..0xC3)
     - decimal fraction (0xC4)
     - bigfloat (0xC5)
     - expected conversions (0xD5..0xD7)
     - simple values (0xE0..0xF3, 0xF8)
     - undefined (0xF7)
    Tagged items (0xC0..0xDB) are not interpreted either; see the note on tagged items below.
 !!! warning "Negative integer overflow"
    CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
@@ -178,7 +181,7 @@ The library maps CBOR types to JSON value types as follows:
 !!! 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.
+    Tagged items will throw a parse error by default. They can be ignored by passing `cbor_tag_handler_t::ignore` to function `from_cbor`. They can be stored by passing `cbor_tag_handler_t::store` to function `from_cbor`.
 ??? 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
@@ -47,58 +47,6 @@ json j = {{"one", 1}, {"two", 2}};
 auto m = j.get<std::map<std::string, int>>();  // {{"one", 1}, {"two", 2}}
 ```
 `#!cpp std::pair` and `#!cpp std::tuple` are also supported, converting positionally to and from a JSON array:
 ```cpp
 json j = {1.0, "hello", 42};
 auto t = j.get<std::tuple<double, std::string, int>>();  // {1.0, "hello", 42}
 ```
 !!! warning "Serializing a `std::pair`/`std::tuple` whose every element is a string-keyed pair"
    When *every* element of a `#!cpp std::pair` or `#!cpp std::tuple` is itself a two-element array whose first
    element is a string (for example `#!cpp std::pair<std::string, int>`), serializing it produces a JSON **object**
    instead of the expected array:
    ```cpp
    using kv = std::pair<std::string, int>;
    json j = std::pair<kv, kv>{{"a", 1}, {"b", 2}};  // {"a":1,"b":2}, not [["a",1],["b",2]]
    ```
    This is a consequence of the [brace-initializer object-detection rule](creating_values.md): the same rule that
    lets `#!cpp json{{"a", 1}, {"b", 2}}` create an object also fires here. The resulting object cannot be read back
    into the original type (`#!cpp get<std::pair<kv, kv>>()` throws [`type_error.302`](../home/exceptions.md#jsonexceptiontype_error302)),
    and duplicate keys collapse into one, losing elements. This only affects `#!cpp std::pair`/`#!cpp std::tuple`
    themselves; a `#!cpp std::vector<std::pair<std::string, int>>`, or a pair/tuple with at least one element that is
    not a string-keyed pair, serializes to an array as expected. To force an array, build one explicitly from the
    elements with [`array`](../api/basic_json/array.md):
    ```cpp
    std::pair<kv, kv> p{{"a", 1}, {"b", 2}};
    json a = json::array({p.first, p.second});  // [["a",1],["b",2]]
    ```
 !!! info "Extracting references into a tuple"
    A tuple type may also hold references (e.g. `#!cpp std::tuple<double&, std::string&>`) to avoid copying: `get`
    then returns a tuple of references pointing directly at the elements stored inside the `basic_json` array,
    rather than a tuple of copies:
    ```cpp
    json j = {1.0, "hello"};
    auto refs = j.get<std::tuple<double&, std::string&>>();
    std::get<1>(refs) = "world";  // modifies j[1] in place
    ```
    A referenced element must name the type the library actually *stores* — one of [`boolean_t`](../api/basic_json/boolean_t.md),
    [`number_integer_t`](../api/basic_json/number_integer_t.md), [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md),
    [`number_float_t`](../api/basic_json/number_float_t.md), [`string_t`](../api/basic_json/string_t.md),
    [`binary_t`](../api/basic_json/binary_t.md), [`array_t`](../api/basic_json/array_t.md), or
    [`object_t`](../api/basic_json/object_t.md). There is nothing else to refer to, so a reference to any other type is a
    compile error even when a conversion would exist: `#!cpp std::tuple<int&>` is rejected, because the library stores a
    `#!cpp number_integer_t` (`#!cpp std::int64_t` by default) and not an `#!cpp int`. This restriction applies only to
    reference elements — a plain `#!cpp std::tuple<int>` converts by value as usual.
 ## Implicit conversions
 By default, a JSON value implicitly converts to a compatible C++ type, so the explicit `get` call can often be omitted:
@@ -146,34 +94,17 @@ which forces the explicit `get` form and can catch unintended conversions at com
    with a custom `adl_serializer<std::optional<T>>` specialization. Prefer `get<std::optional<T>>()`/`get_to()`
    over `static_cast` for optional types.
-!!! warning "Converting to a fixed-size destination does not check the array size"
+!!! warning "Converting to a fixed-size `std::array` does not check length"
-    Some destination types have a size that is fixed by their C++ type rather than by the JSON value:
+    Converting a JSON array to `#!cpp std::array<T, N>` does not check that the JSON array's size matches `N`:
-    `#!cpp std::pair<A, B>`, `#!cpp std::tuple<Ts...>`, `#!cpp std::array<T, N>`, C arrays `#!cpp T[N]`, and
+    if the JSON array is longer, the extra elements are silently dropped; if it is shorter, the remaining
-    `#!cpp std::map`/`#!cpp std::unordered_map` with a non-string key type (which is read from an array of
+    `std::array` elements are left default-constructed. No exception is thrown in either case.
    two-element arrays). All of them read exactly as many elements as they need via
    [`at`](../api/basic_json/at.md) and **never compare the JSON array's size to that number**. The two
    mismatch directions therefore behave differently:
    - The JSON array has **too many** elements: the surplus is **silently discarded**, and no exception is
      thrown.
    - The JSON array has **too few** elements: `at` throws
      [`out_of_range.401`](../home/exceptions.md#jsonexceptionout_of_range401) for the first missing index --
      an out-of-range error, not a [`type_error`](../home/exceptions.md#type-errors), even though the cause
      is a shape mismatch.
    ```cpp
    json j = {1, 2, 3, 4, 5};
-
+    auto a = j.get<std::array<int, 3>>();  // {1, 2, 3} -- elements 4 and 5 silently dropped
    auto a = j.get<std::array<int, 3>>();       // {1, 2, 3} -- elements 4 and 5 silently dropped
    auto p = j.get<std::pair<int, int>>();      // (1, 2)    -- elements 3, 4, and 5 silently dropped
    json k = {1};
    auto q = k.get<std::pair<int, int>>();      // ❌ throws out_of_range.401
    ```
    If a size mismatch is an error in your application, check the size yourself before converting.
 ## Omitting a field when serializing `std::optional`
 By default, `to_json` for `std::optional<T>` writes either the value or `#!json null` -- there is no built-in way
@@ -205,20 +136,6 @@ std::vector<int> numbers = {1, 2, 3};
 json j = numbers;   // [1,2,3]
 ```
 !!! info "Constructing from a C++20 range view"
    A `json` array can also be constructed directly from a C++20 range view (`std::ranges::view`), such as the result
    of `std::views::filter` or `std::views::transform` -- no intermediate container is needed:
    ```cpp
    std::vector<int> nums{1, 2, 37, 42, 21};
    auto filtered = nums | std::views::filter([](int i) { return i > 10; });
    json j(filtered);   // [37,42,21]
    ```
    This requires [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) to be enabled and is unavailable on MinGW due
    to incomplete C++20 ranges support there.
 ## Your own types
 The conversions above are built in for standard types. To make the same syntax work for **your own** types, provide
@@ -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,17 +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)).
+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)).
 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.
 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
 typical object sizes but becomes significant for objects with many thousands of keys; see
 [`ordered_map` complexity](../api/ordered_map.md#complexity). The alternatives above keep a lookup index and do not
 have this cost.
 ### Notes on parsing
@@ -28,22 +28,6 @@ Inputs consisting of multiple values separated by newlines are handled by the [J
 By default, the library rejects comments and trailing commas. Both can be enabled with parameters of the `parse`
 function — see [comments](../comments.md) and [trailing commas](../trailing_commas.md).
 ## Strictness and trailing data
 [`parse`](../../api/basic_json/parse.md) reads a single JSON value and requires the whole input to be consumed: any
 non-whitespace data after the value is reported as a parse error. Use it when you want to guarantee that an input is
 exactly one complete JSON document.
 [`operator>>`](../../api/operator_gtgt.md) follows relaxed `#!cpp std::istream` semantics instead: it parses one JSON
 value and leaves the stream positioned right after it, without requiring the rest of the stream to be consumed. This is
 what makes it possible to read several concatenated values from the same stream, but it also means that "a valid
 document followed by trailing bytes" is accepted rather than rejected. If you are validating conformance, or need to
 reject any input that is not exactly one JSON document, prefer `parse`.
 When using `operator>>` to read several concatenated values this way, a value that is a number must be followed by
 whitespace, because `operator>>` consumes the character that terminates a number — see the
 [`operator>>` notes](../../api/operator_gtgt.md#notes) for details and examples.
 ## SAX vs. DOM parsing
 The library offers two parsing models:
@@ -49,5 +49,4 @@ JSON Lines input with more than one value is treated as invalid JSON by the [`pa
    with a JSON Lines input does not work, because the parser will try to parse one value after the last one.
    This is different from parsing a stream of *concatenated* (non-newline-delimited) JSON values, for which
-    `operator>>` does work, provided that a value that is a number is followed by whitespace -- see its
+    `operator>>` does work -- see its [notes](../../api/operator_gtgt.md#notes) for details.
    [notes](../../api/operator_gtgt.md#notes) for details.
@@ -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 BinaryType = std::vector<std::uint8_t>
    class CustomBaseClass = void
 >
 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
+- [**GitHub CodeQL**](https://github.com/github/codeql), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
 - [**Fraunhofer VVenC**](https://github.com/fraunhoferhhi/vvenc), a fast and efficient encoder for the Versatile Video Coding (H.266/VVC) standard
 - [**GitHub CodeQL**](https://github.com/github/codeql/blob/main/shared/cpp/Diagnostics.h), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
 - [**GoPro ngfx**](https://github.com/gopro/ngfx), a low-level graphics abstraction and profiling framework developed by GoPro
 - [**gRPC**](https://github.com/grpc/grpc/blob/master/tools/artifact_gen/utils.h), a high-performance universal remote procedure call framework
 - [**Hex-Rays**](https://docs.hex-rays.com/user-guide/user-interface/licenses), a reverse engineering toolset for analyzing and decompiling binaries, primarily used for security research and vulnerability analysis
 - [**ImHex**](https://github.com/WerWolv/ImHex), a hex editor designed for reverse engineering, providing advanced features for data analysis and manipulation
 - [**Intel GITS**](https://github.com/intel/gits), a tool for capturing and replaying graphics API calls for debugging and performance analysis
 - [**Intel GPA Framework**](https://intel.github.io/gpasdk-doc/src/licenses.html), a suite of cross-platform tools for capturing, analyzing, and optimizing graphics applications across different APIs
 - [**Intopix**](https://www.intopix.com/software-licensing), a provider of advanced image processing and compression solutions used in software development and AV workflows
 - [**Java SE**](https://www.oracle.com/a/tech/docs/jdk8-lium.pdf), the core Java platform that provides the libraries and runtime needed to build and run general-purpose Java applications
 - [**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
+- [**Meta Yoga**](https://github.com/facebook/yoga), a layout engine that facilitates flexible and efficient user interface design across multiple platforms
 - [**Nix**](https://github.com/NixOS/nix/blob/master/src/nix/build.cc), a purely functional package manager
 - [**Notepad++**](https://github.com/notepad-plus-plus/notepad-plus-plus), a free source code editor that supports various programming languages
 - [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
- [**openFrameworks**](https://github.com/openframeworks/openFrameworks/blob/master/libs/openFrameworks/utils/ofJson.h), a community-developed C++ toolkit for creative coding
+- [**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
@@ -291,10 +291,9 @@ A JSON Pointer array index must be a number.
 ### json.exception.parse_error.110
-When parsing a [binary format](../features/binary_formats/index.md), the byte vector ends before the complete value has
+When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
 been read.
-!!! failure "Example messages"
+!!! failure "Example message"
    ```
    [json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input
@@ -302,9 +301,6 @@ been read.
    ```
    [json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: expected end of input; last byte: 0x5A
    ```
    ```
    [json.exception.parse_error.110] parse error at byte 8: syntax error while parsing BSON number: unexpected end of input
    ```
 ### json.exception.parse_error.112
@@ -333,14 +329,10 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
    ```
    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
    ```
    ```
    [json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size 6 does not match the number of bytes read (5)
    ```
 ### 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
+While parsing a map key, a value that is not a string has been read.
 string was read where one was required (for instance as a map key), or the string's length specification is invalid.
 !!! failure "Example messages"
@@ -353,9 +345,6 @@ string was read where one was required (for instance as a map key), or the strin
    ```
    [json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON char: byte after 'C' must be in range 0x00..0x7F; last byte: 0x82
    ```
    ```
    [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.114
@@ -864,30 +853,13 @@ and this exception no longer occurs.
 ### json.exception.out_of_range.408
-The size of an array or object in a [binary format](../features/binary_formats/index.md) exceeds the maximal capacity:
+The size (following `#`) of an UBJSON array or object exceeds the maximal capacity.
 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
+!!! failure "Example message"
 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"
    ```
    excessive array size: 8658170730974374167
    ```
    ```
    [json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive array size
    ```
    ```
    [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
@@ -926,50 +898,6 @@ A JSON Patch `add` operation cannot be applied because the target location's par
    This exception was added in version 3.13.0. Before that, this situation hit an internal assertion (aborting the program in debug builds) or was silently ignored when assertions were disabled.
 ### json.exception.out_of_range.412
 BSON stores the length of documents, arrays, strings, and binary values in a signed 32-bit integer. This exception is thrown when a value is too large to be described by such a length field.
 !!! failure "Example message"
    ```
    BSON length 2147483661 exceeds maximum of 2147483647
    ```
 !!! note
    This exception was added in version 3.13.0. Before that, the length was silently truncated, and
    [`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
@@ -1002,19 +930,3 @@ A JSON Patch operation 'test' failed. The unsuccessful operation is also printed
    ```
    [json.exception.other_error.501] unsuccessful: {"op":"test","path":"/baz","value":"bar"}
    ```
 ### json.exception.other_error.502
 [`to_ubjson`](../api/basic_json/to_ubjson.md) and [`to_bjdata`](../api/basic_json/to_bjdata.md) were called with
 `use_type = true` but `use_size = false`. UBJSON requires a size marker (`#`) after a type marker (`$`).
 !!! failure "Example message"
    ```
    [json.exception.other_error.502] use_type requires use_size = true
    ```
 !!! note
    This exception was added in version 3.13.0. Before that, debug builds aborted on an assertion and release builds
    wrote a `$` marker without `#`, which [`from_ubjson`](../api/basic_json/from_ubjson.md) then rejected.
@@ -194,27 +194,6 @@ The library uses `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `d
 See [this section](../features/types/number_handling.md#number-serialization) on the library's number handling for more information.
 ### Serializing untrusted or invalid UTF-8
 !!! question "Questions"
    - Why does `dump()` throw when I serialize data that came from the network?
    - Is CVE-2024-34363 a vulnerability in this library?
 Crashes reported against this library that stem from an uncaught
 [`type_error.316`](exceptions.md#jsonexceptiontype_error316) while serializing unvalidated input (e.g.,
 CVE-2024-34363) are a usage issue, not a library vulnerability:
 [`dump()`](../api/basic_json/dump.md) throws in its default `strict` mode because
 [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259#section-8.1) requires JSON text to be valid UTF-8.
 The recommended pattern is to pass a non-strict [`error_handler`](../api/basic_json/error_handler_t.md) or to handle the
 exception:
 ```cpp
 // replace invalid sequences with U+FFFD instead of throwing
 const auto s = j.dump(-1, ' ', false, json::error_handler_t::replace);
 ```
 ### Using JSON values with `std::format` or `fmt`
 !!! question
@@ -14,5 +14,6 @@ You can sponsor this library at [GitHub Sponsors](https://github.com/sponsors/nl
 - [Steve Sperandeo](https://github.com/homer6)
 - [Robert Jefe Lindstädt](https://github.com/eljefedelrodeodeljefe)
 - [Steve Wagner](https://github.com/ciroque)
 - [Lion Yang](https://github.com/LionNatsu)
 Thanks everyone!
@@ -135,31 +135,6 @@ Enable CI build targets. The exact targets are used during the several CI steps
 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.
 !!! warning "Does not apply to a pre-installed package"
    This option only takes effect when building nlohmann/json from source as part of your own
    CMake project (e.g. via [`FetchContent`](#fetchcontent) or [`add_subdirectory`](#external)).
    It has **no effect** on a package that was already built and installed elsewhere (Homebrew,
    vcpkg, a system package, etc.) — the resulting compile definition is baked into the exported
    `nlohmann_jsonTargets.cmake` at install time, and `set(JSON_Diagnostics ON)` before
    `find_package()` does not change it (verified against the Homebrew-installed package: the
    exported target still carries a fixed `$<$<BOOL:OFF>:JSON_DIAGNOSTICS=1>`, regardless of any
    variable set in the consuming project).
    To enable extended diagnostics for a pre-installed package, override the imported target's
    property directly after `find_package()`:
    ```cmake
    find_package(nlohmann_json REQUIRED)
    set_target_properties(nlohmann_json::nlohmann_json PROPERTIES
        INTERFACE_COMPILE_DEFINITIONS "JSON_DIAGNOSTICS=1")
    ```
    This only works cleanly when your project is the sole consumer of that imported target. If
    nlohmann_json is pulled in from more than one place in your dependency graph with different
    `JSON_DIAGNOSTICS` values, you may see a `"JSON_DIAGNOSTICS" redefined` compiler error, since
    conflicting `-D` flags can end up on the same compile command line.
 ### `JSON_Diagnostic_Positions`
 Enable position diagnostics by defining macro [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md). This option is `OFF` by default.
@@ -930,12 +930,6 @@ If you are using [CocoaPods](https://cocoapods.org), you can use the library by
 to your podfile (see [an example](https://bitbucket.org/benman/nlohmann_json-cocoapod/src/master/)). Please file issues
 [here](https://bitbucket.org/benman/nlohmann_json-cocoapod/issues?status=new&status=open).
 ## npm
 This project does not publish an official [npm](https://www.npmjs.com) package. The npm package
 [`nlohmann-json`](https://www.npmjs.com/package/nlohmann-json) (or similarly named packages) is not maintained or
 endorsed by this project. Use one of the package managers listed above, or integrate the single header directly.
 ## ESP-IDF and PlatformIO
 There is no official package published to the [ESP-IDF Component Registry](https://components.espressif.com) or 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
@@ -310,7 +308,6 @@ nav:
          - 'NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, NLOHMANN_JSON_VERSION_PATCH': api/macros/nlohmann_json_version_major.md
  - Community:
      - community/index.md
      - community/ecosystem.md
      - "Code of Conduct": community/code_of_conduct.md
      - community/contribution_guidelines.md
      - community/quality_assurance.md
@@ -395,14 +392,7 @@ plugins:
        - http://nlohmann.github.io/json/*
        - https://nlohmann.github.io/json/*
        - mailto:*
-  - privacy:
+  - 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/*
  - llmstxt:
      markdown_description: >
        JSON for Modern C++ is a C++11 header-only library implementing a JSON
@@ -1,8 +1,8 @@
-wheel==0.48.0
+wheel==0.47.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==9.7.6                             # theme for mkdocs
 mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
 mkdocs-redirects==1.2.3                             # plugin "redirects"
@@ -19,7 +19,6 @@
 #include <unordered_map> // unordered_map
 #include <utility> // pair, declval
 #include <valarray> // valarray
 #include <vector> // vector
 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -333,7 +332,6 @@ template < typename BasicJsonType, typename ConstructibleArrayType,
               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
               !is_compatible_binary_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
@@ -379,36 +377,6 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t&
    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
 }
 template < typename BasicJsonType, typename CompatibleArrayType,
           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
                         int > = 0 >
 inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
 {
    if (j.is_binary())
    {
        bin = static_cast<CompatibleArrayType>(*j.template get_ptr<const typename BasicJsonType::binary_t*>());
    }
    else if (j.is_array())
    {
        from_json_array_impl(j, bin, priority_tag<3> {});
    }
    else
    {
        JSON_THROW(type_error::create(302, concat("type must be binary or array, but is ", j.type_name()), &j));
    }
 }
 template<typename 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 +388,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
+#pragma GCC diagnostic push
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#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);
@@ -177,11 +177,8 @@ struct external_constructor<value_t::array>
    }
    template < typename BasicJsonType, typename CompatibleArrayType,
-               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
-#if JSON_HAS_RANGES && !defined(__MINGW32__)
+                             int > = 0 >
                             && !is_compatible_range_view<CompatibleArrayType>::value
 #endif
                             , int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
    {
        using std::begin;
@@ -221,25 +218,6 @@ struct external_constructor<value_t::array>
        j.set_parents();
        j.assert_invariant();
    }
    // std::ranges does not work properly on MinGW due to incomplete C++20 support
    // see https://github.com/nlohmann/json/issues/4916
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    template<typename BasicJsonType, typename CompatibleArrayType,
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
        j.m_data.m_value = value_t::array;
        for (auto&& x : std::forward<CompatibleArrayType>(arr))
        {
            j.m_data.m_value.array->push_back(x);
            j.set_parent(j.m_data.m_value.array->back());
        }
        j.assert_invariant();
    }
 #endif
 };
 template<>
@@ -377,44 +355,19 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
-                         !is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
                         !is_basic_json<CompatibleArrayType>::value
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
    && !is_compatible_range_view<CompatibleArrayType>::value
 #endif
                         ,
                         int > = 0 >
 inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
 {
    external_constructor<value_t::array>::construct(j, arr);
 }
 #if JSON_HAS_RANGES && !defined(__MINGW32__)
 template < typename BasicJsonType, typename T,
           enable_if_t < is_compatible_range_view<std::remove_cvref_t<T>>::value
                         && !is_compatible_string_type<BasicJsonType, std::remove_cvref_t<T>>::value
                         && !is_compatible_object_type<BasicJsonType, std::remove_cvref_t<T>>::value
                         && !is_basic_json<std::remove_cvref_t<T>>::value, int > = 0 >
 inline void to_json(BasicJsonType& j, T && arr)
 {
    external_constructor<value_t::array>::construct(j, std::forward<T>(arr));
 }
 #endif
 template<typename BasicJsonType>
 inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
 {
    external_constructor<value_t::binary>::construct(j, bin);
 }
 template < typename BasicJsonType, typename CompatibleArrayType,
           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
                         int > = 0 >
 inline void to_json(BasicJsonType& j, const CompatibleArrayType& bin)
 {
    external_constructor<value_t::binary>::construct(j, typename BasicJsonType::binary_t(bin));
 }
 template<typename BasicJsonType, typename T,
         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
@@ -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
+    #pragma clang diagnostic push
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #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
+                            tokens.emplace_back(element.first.c_str());
                            // a null byte is cut short here rather than
                            // truncating the whole message at what()
                            tokens.emplace_back(element.first.data());
                            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
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
                // an integer (e.g., std::byte)
                seed = combine(seed, std::hash<std::uint8_t> {}(static_cast<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
+// SentinelType defaults to IteratorType for backward compatibility, but may
-// a different type, e.g. a C++20 sentinel such as std::default_sentinel_t when
+// be a different type (e.g., a C++20 sentinel or counted_iterator).
 // IteratorType is a std::counted_iterator.
 template<typename IteratorType, typename SentinelType = IteratorType>
 class iterator_input_adapter
 {
    // Whether the number of elements between two positions can be computed in
    // O(1): either the iterator and the sentinel have the same type (plain
    // std::distance) or, in C++20, the sentinel is a sized sentinel for the
    // iterator (std::ranges::distance), e.g. std::default_sentinel_t paired
    // with std::counted_iterator.
    //
    // JSON_HAS_RANGES gates the C++20 branch: on standard libraries with an
    // incomplete <ranges> (libstdc++ < 11, see #4440) evaluating
    // std::contiguous_iterator on a std::counted_iterator is a hard error
    // instead of yielding false, and these traits are instantiated for every
    // adapter. Such toolchains fall back to the pointer-only test and simply
    // use the byte-at-a-time scanner.
    static constexpr bool sentinel_is_sized =
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>;
 #else
        std::is_same<IteratorType, SentinelType>::value;
 #endif
  public:
    using char_type = typename std::iterator_traits<IteratorType>::value_type;
@@ -191,7 +171,7 @@ class iterator_input_adapter
    // in wide_string_input_adapter, which does not expose this).
    static constexpr bool supports_seek =
        std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-        && sentinel_is_sized
+        && std::is_same<IteratorType, SentinelType>::value
        && sizeof(char_type) == 1;
    iterator_input_adapter(IteratorType first, SentinelType last)
@@ -239,60 +219,30 @@ class iterator_input_adapter
  private:
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
-    // library iterators such as those of std::vector and std::string). The
+    // library iterators such as those of std::vector and std::string).
-    // available element count must also be computable in O(1), hence
+    // Computing the available element count needs either same-type iterators
-    // sentinel_is_sized.
+    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
-    static constexpr bool iterator_is_contiguous = sentinel_is_sized &&
+    // e.g. std::counted_iterator paired with std::default_sentinel_t.
-#if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
+    static constexpr bool iterator_is_contiguous =
-        (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
 #else
-        std::is_pointer<IteratorType>::value;
+        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
 #endif
    // number of unread elements in [current, end)
    std::size_t remaining_count() const
    {
 #if JSON_HAS_RANGES && defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        return static_cast<std::size_t>(std::ranges::distance(current, end));
 #else
        return static_cast<std::size_t>(std::distance(current, end));
 #endif
    }
  public:
    // Whether the remaining input is a single contiguous block of 1-byte
    // elements that the lexer can inspect directly (used for the SWAR string
    // fast path).
    static constexpr bool supports_bulk_scan =
        iterator_is_contiguous && sizeof(char_type) == 1;
    // Pointer to the next unread element; only valid when bulk_remaining() > 0.
    const char_type* bulk_data() const
    {
        return &*current;
    }
    // Number of unread elements available as one contiguous block.
    std::size_t bulk_remaining() const
    {
        return remaining_count();
    }
    // Consume @a n elements previously inspected via bulk_data().
    void bulk_skip(std::size_t n)
    {
        std::advance(current, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(n));
    }
  private:
    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-        const std::size_t available = remaining_count() * sizeof(char_type);
+#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
        // std::ranges::distance also supports sized sentinels of a different
        // type (e.g. std::counted_iterator + std::default_sentinel_t)
        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
 #else
        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
 #endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -395,12 +345,8 @@ struct wide_string_input_helper<BaseInputAdapter, 4>
            }
            else
            {
-                // A code point above U+10FFFF has no UTF-8 encoding. Passing the
+                // unknown character
-                // unit through would narrow it to int, where 0xFFFFFFFF becomes
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                // char_traits<char>::eof() and would end the input silently, so
                // emit a byte that is never valid UTF-8 and let the decoder
                // reject it.
                utf8_bytes[0] = 0xFF;
                utf8_bytes_filled = 1;
            }
        }
@@ -449,30 +395,17 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
            }
            else
            {
-                // A supplementary code point is a high surrogate (0xD800..0xDBFF)
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
                // followed by a low surrogate (0xDC00..0xDFFF). A lone low
                // surrogate, a high surrogate at the end of the input, or a high
                // surrogate followed by any other unit is malformed UTF-16. In
                // that case the offending unit is passed through unchanged so the
                // UTF-8 decoder rejects it, matching how \uXXXX surrogate escapes
                // are handled in the lexer.
                bool valid_pair = false;
                if (wc <= 0xDBFF && JSON_HEDLEY_UNLIKELY(!input.empty()))
                {
                    const auto wc2 = static_cast<unsigned int>(input.get_character());
-                    if (0xDC00 <= wc2 && wc2 <= 0xDFFF)
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
-                    {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
-                        const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
-                        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
-                        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
-                        utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes_filled = 4;
                        utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
                        utf8_bytes_filled = 4;
                        valid_pair = true;
                    }
                }
-
+                else
                if (!valid_pair)
                {
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                    utf8_bytes_filled = 1;
@@ -620,46 +553,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 +580,12 @@ struct container_input_adapter_factory< ContainerType,
 }  // namespace container_input_adapter_factory_impl
-// General container path (iterator-based). Contiguous single-byte containers
+template<typename ContainerType>
-// are excluded here and routed through the pointer-based overload below.
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType&& container)
 template < typename ContainerType,
           enable_if_t < !is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(ContainerType && container)
 {
    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(std::forward<ContainerType>(container));
 }
 // Contiguous single-byte containers (std::string, std::vector<char>, ...) are
 // wrapped in a pointer-based adapter so the contiguous fast paths apply in every
 // standard. The pointer keeps the container's own element type (const char* for
 // std::string, const std::uint8_t* for std::vector<std::uint8_t>, ...), so the
 // resulting char_type - and therefore the parsing behavior - is byte-for-byte
 // identical to the iterator-based path; only the raw pointer additionally
 // enables the bulk fast paths. The container outlives the adapter for the whole
 // parse (temporaries live until the end of the full expression), exactly as the
 // iterators it replaces did.
 template < typename ContainerType,
           enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
 auto input_adapter(const ContainerType& container)
 -> decltype(input_adapter(container.data(), container.data() + container.size()))
 {
    return input_adapter(container.data(), container.data() + container.size());
 }
 // specialization for std::string
 using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
@@ -8,17 +8,15 @@
 #pragma once
 #include <algorithm> // find_if, min
 #include <cstddef>
 #include <string> // string
 #include <type_traits> // enable_if_t
-#include <utility> // move, pair
+#include <utility> // move
 #include <vector> // vector
 #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,
+        handle_value(val);
        // so hand the buffer over instead of copying it
        handle_value(std::move(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;
    }
@@ -278,7 +249,7 @@ class json_sax_dom_parser
        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }
        return true;
@@ -327,12 +298,7 @@ class json_sax_dom_parser
        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+            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;
@@ -404,10 +370,8 @@ class json_sax_dom_parser
                case value_t::string:
                {
-                    // escape sequences make the token longer than the value it
+                    // include the length of the quotes, which is 2
-                    // parses to, so the start position cannot be derived from
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
                    // the value; use the offset the lexer recorded instead
                    v.start_position = m_lexer_ref->get_token_start_position();
                    break;
                }
@@ -566,16 +530,12 @@ class json_sax_dom_callback_parser
    bool string(string_t& val)
    {
-        // json_sax documents that the passed value may be moved from,
+        handle_value(val);
        // so hand the buffer over instead of copying it
        handle_value(std::move(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 +546,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);
@@ -611,7 +566,7 @@ class json_sax_dom_callback_parser
            // check object limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
            }
        }
        return true;
@@ -624,24 +579,11 @@ 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())
        {
-            auto& obj = *ref_stack.back()->m_data.m_value.object;
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
            const auto it = obj.find(val);
            if (it != obj.end())
            {
                // this is a duplicate key (legal in JSON); remember its
                // current value so it can be restored later if the new
                // value is rejected by the callback, instead of being
                // erased together with the discarded placeholder
                duplicate_key_stash.emplace_back(&(it->second), it->second);
            }
            object_element = &(obj[val] = discarded);
        }
        return true;
@@ -653,18 +595,13 @@ class json_sax_dom_callback_parser
        {
            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
            {
-                // discard object, unless this slot holds a duplicate key's
+                // discard object
-                // previous value pending restoration, in which case that
+                *ref_stack.back() = discarded;
                // value is restored instead of being discarded
                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
                {
                    *ref_stack.back() = discarded;
 #if JSON_DIAGNOSTIC_POSITIONS
-                    // Set start/end positions for discarded object.
+                // Set start/end positions for discarded object.
-                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
                }
            }
            else
            {
@@ -678,25 +615,25 @@ class json_sax_dom_callback_parser
 #endif
                ref_stack.back()->set_parents();
                // this object is finally, definitively kept; drop any
                // pending duplicate-key stash entry for its slot since it
                // can no longer be restored
                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
        }
        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);
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
            {
                if (it->is_discarded())
                {
                    ref_stack.back()->erase(it);
                    break;
                }
            }
        }
        return true;
@@ -707,9 +644,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);
@@ -730,12 +664,7 @@ class json_sax_dom_callback_parser
            // check array limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+                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> {});
            }
        }
@@ -745,9 +674,8 @@ class json_sax_dom_callback_parser
    bool end_array()
    {
        bool keep = true;
        const bool stored = ref_stack.back() != nullptr;
-        if (stored)
+        if (ref_stack.back())
        {
            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
            if (keep)
@@ -762,50 +690,28 @@ class json_sax_dom_callback_parser
 #endif
                ref_stack.back()->set_parents();
                // this array is finally, definitively kept; drop any
                // pending duplicate-key stash entry for its slot since it
                // can no longer be restored
                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
            else
            {
-                // discard array, unless this slot holds a duplicate key's
+                // discard array
-                // previous value pending restoration, in which case that
+                *ref_stack.back() = discarded;
                // value is restored instead of being discarded
                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
                {
                    *ref_stack.back() = discarded;
 #if JSON_DIAGNOSTIC_POSITIONS
-                    // Set start/end positions for discarded array.
+                // Set start/end positions for discarded array.
-                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
                }
            }
        }
        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())
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
        {
-            if (!keep && ref_stack.back()->is_array())
+            ref_stack.back()->m_data.m_value.array->pop_back();
            {
                ref_stack.back()->m_data.m_value.array->pop_back();
            }
            else if ((!keep || !stored) && ref_stack.back()->is_object())
            {
                // 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);
            }
        }
        return true;
@@ -859,10 +765,8 @@ class json_sax_dom_callback_parser
                case value_t::string:
                {
-                    // escape sequences make the token longer than the value it
+                    // include the length of the quotes, which is 2
-                    // parses to, so the start position cannot be derived from
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
                    // the value; use the offset the lexer recorded instead
                    v.start_position = m_lexer_ref->get_token_start_position();
                    break;
                }
@@ -897,96 +801,6 @@ class json_sax_dom_callback_parser
    }
 #endif
    /// if there is a pending duplicate-key stash entry for this exact slot,
    /// remove it from the stash; if restore_value is true, the stashed
    /// previous value is moved back into the slot first (use this when the
    /// new value at that slot was rejected); otherwise the stash entry is
    /// simply dropped (use this when the new value was accepted, so it
    /// correctly supersedes the old one and no restore should ever happen
    /// for this slot again)
    /// @return whether a matching stash entry was found (and processed)
    bool resolve_duplicate_key_stash(BasicJsonType* slot, bool restore_value)
    {
        const auto it = std::find_if(duplicate_key_stash.begin(), duplicate_key_stash.end(),
                                     [slot](const std::pair<BasicJsonType*, BasicJsonType>& entry)
        {
            return entry.first == slot;
        });
        if (it == duplicate_key_stash.end())
        {
            return false;
        }
        if (restore_value)
        {
            *slot = std::move(it->second);
        }
        duplicate_key_stash.erase(it);
        return true;
    }
    /*!
    @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
    {
        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object()
                && !key_stack.empty())
        {
            return key_stack.back();
        }
        return string_t{};
    }
    /*!
    @brief remove the discarded value the callback rejected from its parent,
    unless it is a duplicate key's slot with a stashed previous value, in
    which case that previous value is restored instead
    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
    */
    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())
            {
                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())
            {
                // a duplicate key's slot has a stashed previous value that
                // must be restored instead of being erased
                if (!resolve_duplicate_key_stash(&it->second, true))
                {
                    object.erase(it);
                }
            }
        }
    }
    /*!
    @param[in] v  value to add to the JSON value we build during parsing
    @param[in] skip_callback  whether we should skip calling the callback
@@ -1027,21 +841,6 @@ class json_sax_dom_callback_parser
        // do not handle this value if we just learnt it shall be discarded
        if (!keep)
        {
            // if the value was to become an object member, key() already
            // stored a placeholder for it that has to be removed again
            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);
                }
            }
            return {false, nullptr};
        }
@@ -1072,10 +871,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)
        {
@@ -1084,16 +881,6 @@ class json_sax_dom_callback_parser
        JSON_ASSERT(object_element);
        *object_element = std::move(value);
        if (!skip_callback)
        {
            // this scalar value finally, definitively replaces whatever was
            // at this slot; drop any pending duplicate-key stash entry for
            // it since it can no longer be restored (a container value at
            // this slot is resolved later, in end_object()/end_array(),
            // since skip_callback is true for the placeholder handling that
            // happens here for those)
            resolve_duplicate_key_stash(object_element, false);
        }
        return {true, object_element};
    }
@@ -1105,20 +892,8 @@ 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;
    /// stash of (slot pointer, previous value) for object members that
    /// already existed when key() was called again for the same key
    /// (duplicate keys); used to restore the previous value if the new
    /// value is later rejected by the callback, instead of erasing the
    /// member entirely
    std::vector<std::pair<BasicJsonType*, BasicJsonType>> duplicate_key_stash {};
    /// whether a syntax error occurred
    bool errored = false;
    /// callback function
@@ -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
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-        if (mantissa_end == std::string::npos)
+        errno = 0;
        {
            mantissa_end = token_buffer.size();
        }
-        return convert_number(number_type, mantissa_end);
+        // try to parse integers first and fall back to floats
    }
    /*!
    @brief convert an already-validated integer token to its value
    The digit sequence in [first, last) has been validated by the caller, so a
    dedicated parser can avoid the locale/errno overhead of std::strtoull.
    @return the token type on success; token_type::uninitialized if @a
            number_type is not an integer type or the value does not fit, in
            which case the caller falls back to the floating-point conversion
            (matching the previous std::strtoull/std::strtoll behavior)
    */
    token_type convert_integer(token_type number_type, const char* first, const char* last)
    {
        if (number_type == token_type::value_unsigned)
        {
-            if (parse_integer_unsigned(first, last, value_unsigned))
+            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;
+                value_integer = static_cast<number_integer_t>(x);
-            }
+                if (value_integer == x)
-        }
+                {
-
+                    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;
            }
        }
        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Prefer std::from_chars
+        // integer conversion above failed
        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
        // otherwise the exact Clinger fast path (double only); otherwise the
        // locale-aware strtof/strtod.
        if (parse_float_from_chars(num_begin, num_end, value_float))
        {
            return token_type::value_float;
        }
        // Skipping a fast path that cannot succeed is lossless and saves a full
        // extra pass over the token's bytes, which otherwise shows up on
        // high-precision inputs such as canada.json
        if (mantissa_fits_clinger(mantissa_end)
                && parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
        {
            return token_type::value_float;
        }
        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
        strtof(value_float, token_buffer.data(), &endptr);
        // we checked the number format before
@@ -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
@@ -1740,11 +1357,6 @@ scan_number_done:
        token_buffer.clear();
        decimal_point_position = std::string::npos;
 #if JSON_DIAGNOSTIC_POSITIONS
        // the first character of the token has already been read, hence the -1
        token_start_position = position.chars_read_total - 1;
 #endif
        note_token_start(std::integral_constant<bool, lazy_token_string> {});
    }
@@ -1776,7 +1388,8 @@ scan_number_done:
    */
    char_int_type get()
    {
-        advance_position();
+        ++position.chars_read_total;
        ++position.chars_read_current_line;
        if (next_unget)
        {
@@ -1788,23 +1401,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 +1408,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 +1441,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
        {
@@ -1957,15 +1519,6 @@ scan_number_done:
        return position;
    }
 #if JSON_DIAGNOSTIC_POSITIONS
    /// return the offset of the first character of the last read token; unlike
    /// the token's parsed value, this accounts for escape sequences
    constexpr std::size_t get_token_start_position() const noexcept
    {
        return token_start_position;
    }
 #endif
    /// seekable adapter: rebuild the last read token from the input on demand
    const std::vector<char_type>& collect_token_chars(std::vector<char_type>& out, std::true_type /*lazy*/) const
    {
@@ -2045,37 +1598,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 +1680,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 +1711,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 {};
@@ -2194,12 +1719,6 @@ scan_number_done:
    /// the last read token on error for seekable adapters (see collect_token_chars)
    std::size_t token_string_start = 0;
 #if JSON_DIAGNOSTIC_POSITIONS
    /// start offset of the current token within the input, used to report
    /// diagnostic positions (see reset())
    std::size_t token_start_position = 0;
 #endif
    /// buffer for variable-length tokens (numbers, strings)
    string_t token_buffer {};
@@ -2215,13 +1734,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 ignore_trailing_commas_ = false)
                    const bool discard_number_values_ = 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_)
    {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	0e03ecee10	Extend memcpy fast path to sized sentinels (e.g. std::counted_iterator) Extend the memcpy fast path in iterator_input_adapter to sized sentinels of a different type, not just same-type iterator pairs. std::counted_iterator paired with std::default_sentinel_t already satisfies std::contiguous_iterator and std::sized_sentinel_for, so std::ranges::distance (C++20) lets that combination reach the fast path too, instead of silently falling back to the byte-by-byte path. - iterator_is_contiguous now also allows std::sized_sentinel_for<SentinelType, IteratorType> under C++20, gated the same way as the existing std::contiguous_iterator detection. - get_elements_impl's fast path uses std::ranges::distance under C++20 (works for both same-type and sized-sentinel pairs) and falls back to std::distance pre-C++20, where SentinelType is always IteratorType. - Add a C++20-only test exercising json::parse/accept with std::counted_iterator + std::default_sentinel_t. - Document std::default_sentinel_t + std::counted_iterator as a SentinelType example across parse.md, accept.md, sax_parse.md, and the five from_*.md pages, replacing an earlier ambiguously worded bullet. Addresses review feedback: https://github.com/nlohmann/json/pull/5265#discussion_r3564237584 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-11 16:26:09 +02:00
Niels Lohmann	d23806a327	Fix clang-tidy misc-const-correctness in heterogeneous sentinel test json_str is only read via .data()/.size() and never reassigned, so clang-tidy correctly flags it as const-able. Verified against the exact CI job (silkeh/clang:dev, ci_clang_tidy target) by running clang-tidy directly on this file plus the five binary-format sentinel tests touched by prior commits; all are now clean. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-11 10:06:11 +02:00
Niels Lohmann	fa9741f0ce	Fix clang-tidy hicpp-named-parameter and misc-const-correctness - Drop the unused reversed-order operator!= overload from utils::istreambuf_sentinel (only iterator != sentinel is ever evaluated) and name the remaining friend's sentinel parameter, fixing hicpp-named-parameter/readability-named-parameter. - Mark the istreambuf_iterator first/last helper variable const in the five binary-format sentinel tests, fixing misc-const-correctness. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-11 00:10:23 +02:00
Niels Lohmann	da95d1184e	Fix -Wunneeded-internal-declaration for CustomSentinel in test CustomSentinel lives in an anonymous namespace (internal linkage), and the library's parse loop only ever evaluates the iterator-first direction (it != last), so the reversed-order friend operator!= was never referenced. Clang's -Weverything flags such unused internal declarations as an error. Drop the unused overload; the used direction is enough to satisfy can_compare_ne's either-order detection. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-10 23:25:21 +02:00
Niels Lohmann	146e5e0bc7	Merge iterator+sentinel overloads and fix ambiguity/CI issues Address PR review feedback and CI failures: - Merge the separate same-type and sentinel-type iterator overloads of parse(), accept(), sax_parse(), and the five from_* binary deserializers into a single overload with SentinelType defaulted to IteratorType, as suggested in review. Applied the same simplification to the detail::input_adapter() free functions. - Fix a latent ambiguity: some compilers (e.g. GCC 4.8) unreliably SFINAE the operator!= detection for std::nullptr_t against container/string types, making calls like parse(s, nullptr, ...) ambiguous with the compatible-input overload. can_compare_ne now explicitly excludes std::nullptr_t as a SentinelType. - Use a named enable_if_t template parameter instead of an unnamed function parameter for the SFINAE guard, fixing a clang-tidy hicpp-named-parameter/readability-named-parameter failure. - Update parse.md, accept.md, sax_parse.md, and the five from_*.md pages to document the merged overload instead of separate (2)/(3) overloads, also fixing an over-160-char line that broke the documentation style_check CI job. - Rework the BSON iterator+sentinel test to parse a BSON file already present in the test suite instead of writing/deleting a temp file. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-10 23:15:17 +02:00
Niels Lohmann	2269656bc6	Add iterator+sentinel tests and docs for binary deserializers This commit extends the C++20 ranges support (iterator+sentinel pairs) to the binary format deserializers from_cbor, from_msgpack, from_ubjson, from_bjdata, and from_bson, matching what was already done for parse(), accept(), and sax_parse(). Changes: - Add istreambuf_sentinel helper to test_utils.hpp for EOF detection in tests - Add 5 new test cases that read binary files directly via std::istreambuf_iterator<char> + sentinel, without pre-buffering - Update documentation for all 5 from_* functions to document overload (3) with SentinelType parameter - All tests pass; verified against existing test suite data - Fix potential buffer over-read warning in heterogeneous iterator test Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-10 19:50:04 +02:00