Deduplicate UBJSON/BJData length-type error message

The "expected length type specification" parse error was built with an identical if/else block in both get_ubjson_string() and get_ubjson_size_value(), each branching on the input format to pick the marker list. Extract a single unexpected_length_type_message() helper that selects the markers via a ternary and appends the caller-supplied infix, removing four near-duplicate message strings and centralizing the marker list. Error messages are unchanged. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Tv6SnfYbcx8y3y4PrECcto
2026-08-21 16:43:17 +00:00 · 2026-07-22 21:03:03 +00:00
73 changed files with 1563 additions and 4841 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 test case referencing the fixed issue. Its predecessors
+When fixing a bug, edit `unit-regression2.cpp` and add a section referencing the fixed issue.
 `unit-regression1.cpp` and `unit-regression2.cpp` stay as they are: the MinGW linker fails on the object a file this
 size produces, which is why the tests are spread over several files in the first place.
 #### 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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+      uses: github/codeql-action/init@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
      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@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+      uses: github/codeql-action/autobuild@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+      uses: github/codeql-action/analyze@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
@@ -19,7 +19,7 @@ jobs:
      pull-requests: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+        uses: github/codeql-action/upload-sarif@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -17,7 +17,7 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+        uses: github/codeql-action/upload-sarif@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
        with:
          sarif_file: results.sarif
@@ -32,12 +32,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+        uses: github/codeql-action/upload-sarif@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -16,11 +16,11 @@ jobs:
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.1
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit
-      - uses: actions/stale@4391f3da665fdf50b6810c1a66712fb9ba21aa93 # v11.0.0
+      - uses: actions/stale@1e223db275d687790206a7acac4d1a11bd6fe629 # v10.4.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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_no_thread_local]
+        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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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@b09bb98e06d4d774595224525879c09bc6e98c40 # v2.20.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,20 +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.
      # Do not add -O1 here to shrink the objects further: it does make them
      # link, but the binaries clang 11.0.1 and clang 18.1.8 then produce crash
      # before doctest prints its first line - 39 of 102 tests on clang 18.
      # Keep the objects small by splitting the test files instead.
      - 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 ^
@@ -183,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
@@ -196,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)
@@ -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:
@@ -242,25 +242,6 @@ add_custom_target(ci_test_noglobaludls
    COMMENT "Compile and test with global UDLs disabled"
 )
 ###############################################################################
 # Disable thread-local storage.
 ###############################################################################
 # Without thread-local storage, copying and comparing cannot bound their
 # descent and handle every object and array without the call stack. Those paths
 # are otherwise only reached by values nested deeper than the bound, so this
 # target is what runs the whole test suite through them.
 add_custom_target(ci_test_no_thread_local
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON
    -DCMAKE_CXX_FLAGS=-DJSON_NO_THREAD_LOCAL
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_no_thread_local
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_no_thread_local
    COMMAND cd ${PROJECT_BINARY_DIR}/build_no_thread_local && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test without thread-local storage"
 )
 ###############################################################################
 # Coverage.
 ###############################################################################
@@ -313,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
 )
@@ -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:
@@ -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.
@@ -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.
@@ -40,9 +40,6 @@ 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
@@ -22,7 +22,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_HAS_STD_FORMAT**](json_has_std_format.md) - control `std::format`/`std::formatter` support
 - [**JSON_HAS_THREE_WAY_COMPARISON**](json_has_three_way_comparison.md) - control 3-way comparison support
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_NO_THREAD_LOCAL**](json_no_thread_local.md) - switch off the use of `thread_local` storage
 - [**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
@@ -1,48 +0,0 @@
 # JSON_NO_THREAD_LOCAL
 ```cpp
 #define JSON_NO_THREAD_LOCAL
 ```
 When defined, the library does not use `#!cpp thread_local` storage. This is relevant for the few environments whose
 toolchain does not support it.
 Copying a value and comparing two values both descend into the first levels by letting the containers copy or compare
 themselves, and finish whatever is nested deeper than that without the call stack, so that neither can exhaust the stack
 however deeply the values are nested. Each counts the levels it has descended into in a `#!cpp thread_local` variable, as
 a counter shared between threads would be raced.
 Without those counters, no descent can be bounded safely, so objects and arrays are copied and compared without the call
 stack right away. Both keep working exactly as they do otherwise - the same values come out, the same comparisons hold,
 and deeply nested values are handled just as safely - but both are slower, because the containers no longer copy or
 compare themselves. Copying the benchmark documents takes 9% (`canada.json`) to 34% (`twitter.json`) longer, and
 comparing two equal ones 10% (`citm_catalog.json`) to 90% (`canada.json`) longer.
 ## Default definition
 By default, `#!cpp JSON_NO_THREAD_LOCAL` is not defined.
 ```cpp
 #undef JSON_NO_THREAD_LOCAL
 ```
 The library defines it by itself for Clang targeting MinGW, which does not survive the `#!cpp thread_local` storage:
 copying a value segfaults there, with both old and current Clang versions, while GCC targeting MinGW is unaffected.
 Copying and comparing fall back to working without the call stack there, as they do whenever the macro is defined.
 ## Examples
 ??? example
    The code below forces the library not to use `#!cpp thread_local` storage.
    ```cpp
    #define JSON_NO_THREAD_LOCAL 1
    #include <nlohmann/json.hpp>
    ...
    ```
 ## Version history
 - Added in version 3.12.1.
@@ -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,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,19 +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`,
    - 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,8 +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.
 ??? 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
@@ -66,14 +66,8 @@ auto t = j.get<std::tuple<double, std::string, int>>();  // {1.0, "hello", 42}
    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),
+    A referenced type must be one the library actually stores (or an arithmetic type it can convert to/from);
-    [`number_integer_t`](../api/basic_json/number_integer_t.md), [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md),
+    otherwise this is a compile error.
    [`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
@@ -122,34 +116,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
@@ -91,14 +91,6 @@ security reasons (e.g., Intel Software Guard Extensions (SGX)).
 See [full documentation of `JSON_NO_IO`](../api/macros/json_no_io.md).
 ## `JSON_NO_THREAD_LOCAL`
 When defined, the library does not use `#!cpp thread_local` storage. Copying a value and comparing two values then
 always avoid the call stack rather than descending into a bounded number of levels first, which is slower but yields the
 same values and the same comparisons.
 See [full documentation of `JSON_NO_THREAD_LOCAL`](../api/macros/json_no_thread_local.md).
 ## `JSON_SKIP_LIBRARY_VERSION_CHECK`
 When defined, the library will not create a compiler warning when a different version of the library was already
@@ -53,12 +53,6 @@ If you do want to preserve the **insertion order**, you can use the type [`nlohm
 Alternatively, you can use a more sophisticated ordered map like [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) ([integration](https://github.com/nlohmann/json/issues/546#issuecomment-304447518)) or [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
 The [`ordered_map`](../api/ordered_map.md) behind `nlohmann::ordered_json` is deliberately minimal and has no lookup
 index, so every key access is a linear scan and building an object of `n` keys costs O(n²). This is unnoticeable at
 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
 Note that you also need to call the right [`parse`](../api/basic_json/parse.md) function when reading from a file.
@@ -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.
@@ -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,21 +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).
-!!! failure "Example messages"
+!!! failure "Example message"
    ```
    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.409
@@ -917,22 +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.
 ## Further exceptions
 This exception is thrown in case of errors that cannot be classified with the
@@ -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!
@@ -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
@@ -291,7 +291,6 @@ nav:
          - 'JSON_HAS_THREE_WAY_COMPARISON': api/macros/json_has_three_way_comparison.md
          - 'JSON_NOEXCEPTION': api/macros/json_noexception.md
          - 'JSON_NO_IO': api/macros/json_no_io.md
          - 'JSON_NO_THREAD_LOCAL': api/macros/json_no_thread_local.md
          - 'JSON_SKIP_LIBRARY_VERSION_CHECK': api/macros/json_skip_library_version_check.md
          - 'JSON_SKIP_UNSUPPORTED_COMPILER_CHECK': api/macros/json_skip_unsupported_compiler_check.md
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
@@ -309,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
@@ -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.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"
@@ -163,44 +163,14 @@ class binary_reader
    // BSON //
    //////////
    /*!
    @brief Validate a BSON document's declared size against the bytes read.
    A BSON document starts with an int32 that counts its own total length in
    bytes, including that prefix and the trailing 0x00. The reader is driven
    by the terminator rather than the declared length, so without this check a
    nested document could declare a length that disagrees with where its
    terminator actually falls and quietly hand the bytes in between to the
    enclosing document. A well-formed document is at least 5 bytes (the prefix
    plus the terminator); the equality also rejects those impossible sizes,
    since at least 5 bytes are always consumed.
    @param[in] document_start  value of chars_read before the size prefix
    @param[in] document_size   the declared document size
    @return whether the declared size matches the number of bytes read
    */
    bool check_bson_document_size(const std::size_t document_start, const std::int32_t document_size)
    {
        if (JSON_HEDLEY_UNLIKELY(document_size < 0 || static_cast<std::size_t>(document_size) != chars_read - document_start))
        {
            return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
                                    exception_message(input_format_t::bson, concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr));
        }
        return true;
    }
    /*!
    @brief Reads in a BSON-object and passes it to the SAX-parser.
    @return whether a valid BSON-value was passed to the SAX parser
    */
    bool parse_bson_internal()
    {
        const std::size_t document_start = chars_read;
        std::int32_t document_size{};
-        if (!get_number<std::int32_t, true>(input_format_t::bson, document_size))
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
        {
            return false;
        }
        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
        {
@@ -212,11 +182,6 @@ class binary_reader
            return false;
        }
        if (JSON_HEDLEY_UNLIKELY(!check_bson_document_size(document_start, document_size)))
        {
            return false;
        }
        return sax->end_object();
    }
@@ -290,10 +255,7 @@ class binary_reader
        // All BSON binary values have a subtype
        std::uint8_t subtype{};
-        if (JSON_HEDLEY_UNLIKELY(!get_number<std::uint8_t>(input_format_t::bson, subtype)))
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
        {
            return false;
        }
        result.set_subtype(subtype);
        return get_binary(input_format_t::bson, len, result);
@@ -346,8 +308,7 @@ class binary_reader
            case 0x08: // boolean
            {
-                std::uint8_t value{};
+                return sax->boolean(get() != 0);
                return get_number<std::uint8_t>(input_format_t::bson, value) && sax->boolean(value != 0);
            }
            case 0x0A: // null
@@ -436,12 +397,8 @@ class binary_reader
    */
    bool parse_bson_array()
    {
        const std::size_t document_start = chars_read;
        std::int32_t document_size{};
-        if (!get_number<std::int32_t, true>(input_format_t::bson, document_size))
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
        {
            return false;
        }
        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
        {
@@ -453,11 +410,6 @@ class binary_reader
            return false;
        }
        if (JSON_HEDLEY_UNLIKELY(!check_bson_document_size(document_start, document_size)))
        {
            return false;
        }
        return sax->end_array();
    }
@@ -465,6 +417,15 @@ class binary_reader
    // CBOR //
    //////////
    /*!
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true) or whether the last read character should
                         be considered instead (false)
    @param[in] tag_handler how CBOR tags should be treated
    @return whether a valid CBOR value was passed to the SAX parser
    */
    template<typename NumberType>
    bool get_cbor_negative_integer()
    {
@@ -483,14 +444,6 @@ class binary_reader
        return sax->number_integer(static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(number));
    }
    /*!
    @param[in] get_char  whether a new character should be retrieved from the
                         input (true) or whether the last read character should
                         be considered instead (false)
    @param[in] tag_handler how CBOR tags should be treated
    @return whether a valid CBOR value was passed to the SAX parser
    */
    bool parse_cbor_internal(const bool get_char,
                             const cbor_tag_handler_t tag_handler)
    {
@@ -703,15 +656,13 @@ class binary_reader
            case 0x9A: // array (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
-                std::size_t size{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
            }
            case 0x9B: // array (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
-                std::size_t size{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
            }
            case 0x9F: // array (indefinite length)
@@ -759,27 +710,19 @@ class binary_reader
            case 0xBA: // map (four-byte uint32_t for n follow)
            {
                std::uint32_t len{};
-                std::size_t size{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
            }
            case 0xBB: // map (eight-byte uint64_t for n follow)
            {
                std::uint64_t len{};
-                std::size_t size{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
                return get_number(input_format_t::cbor, len) && get_cbor_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
            }
            case 0xBF: // map (indefinite length)
                return get_cbor_object(detail::unknown_size(), tag_handler);
-            case 0xC0: // tagged item
+            case 0xC6: // tagged item
            case 0xC1:
            case 0xC2:
            case 0xC3:
            case 0xC4:
            case 0xC5:
            case 0xC6:
            case 0xC7:
            case 0xC8:
            case 0xC9:
@@ -794,9 +737,6 @@ class binary_reader
            case 0xD2:
            case 0xD3:
            case 0xD4:
            case 0xD5:
            case 0xD6:
            case 0xD7:
            case 0xD8: // tagged item (1 byte follows)
            case 0xD9: // tagged item (2 bytes follow)
            case 0xDA: // tagged item (4 bytes follow)
@@ -819,37 +759,25 @@ class binary_reader
                            case 0xD8:
                            {
                                std::uint8_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                {
                                    return false;
                                }
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                {
                                    return false;
                                }
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                {
                                    return false;
                                }
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                {
                                    return false;
                                }
                                break;
                            }
                            default:
@@ -867,40 +795,28 @@ class binary_reader
                            case 0xD8:
                            {
                                std::uint8_t subtype{};
-                                if (!get_number(input_format_t::cbor, subtype))
+                                get_number(input_format_t::cbor, subtype);
                                {
                                    return false;
                                }
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t subtype{};
-                                if (!get_number(input_format_t::cbor, subtype))
+                                get_number(input_format_t::cbor, subtype);
                                {
                                    return false;
                                }
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t subtype{};
-                                if (!get_number(input_format_t::cbor, subtype))
+                                get_number(input_format_t::cbor, subtype);
                                {
                                    return false;
                                }
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t subtype{};
-                                if (!get_number(input_format_t::cbor, subtype))
+                                get_number(input_format_t::cbor, subtype);
                                {
                                    return false;
                                }
                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
                                break;
                            }
@@ -942,7 +858,7 @@ class binary_reader
                const auto byte1 = static_cast<unsigned char>(byte1_raw);
                const auto byte2 = static_cast<unsigned char>(byte2_raw);
-                // Code from RFC 8949, Appendix D, Figure 3:
+                // Code from RFC 7049, Appendix D, Figure 3:
                // As half-precision floating-point numbers were only added
                // to IEEE 754 in 2008, today's programming platforms often
                // still only have limited support for them. It is very
@@ -955,8 +871,8 @@ class binary_reader
                {
                    const int exp = (half >> 10u) & 0x1Fu;
                    const unsigned int mant = half & 0x3FFu;
-                    JSON_ASSERT(exp <= 31);
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
-                    JSON_ASSERT(mant <= 1023);
+                    JSON_ASSERT(mant <= 1024);
                    switch (exp)
                    {
                        case 0:
@@ -1191,31 +1107,6 @@ class binary_reader
        }
    }
    /*!
    @brief narrow a definite CBOR array/map length to std::size_t
    A definite length is rejected if it does not fit in std::size_t or if it
    equals detail::unknown_size(), which is reserved to mark an indefinite-
    length container and would otherwise make the length read as indefinite.
    Both cases exceed any container's max_size(), so no representable input
    is affected.
    @param[in]  len      the declared length
    @param[out] result   the length narrowed to std::size_t
    @param[in]  context  "array" or "map", for the error message
    @return whether the length is usable
    */
    bool get_cbor_container_size(const std::uint64_t len, std::size_t& result, const char* context)
    {
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::size_t>(len) || len == detail::unknown_size()))
        {
            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                    exception_message(input_format_t::cbor, concat("excessive ", context, " size"), "size"), nullptr));
        }
        result = conditional_static_cast<std::size_t>(len);
        return true;
    }
    /*!
    @param[in] len  the length of the array or detail::unknown_size() for an
                    array of indefinite size
@@ -1978,6 +1869,24 @@ class binary_reader
        return true;
    }
    /*!
    @brief create the error message for a missing/invalid length-type marker
    Used both when reading a UBJSON/BJData string and when reading an optimized
    container size. The accepted markers depend on the input format, and the
    size variant appends " after '#'" via @a infix.
    @param[in] last_token  the offending byte as returned by get_token_string()
    @param[in] infix       extra context inserted after the marker list
    @return the formatted error message
    */
    std::string unexpected_length_type_message(const std::string& last_token, const char* infix) const
    {
        return concat("expected length type specification (",
                      input_format == input_format_t::bjdata ? "U, i, u, I, m, l, M, L" : "U, i, I, l, L",
                      ")", infix, "; last byte: 0x", last_token);
    }
    /*!
    @brief reads a UBJSON string
@@ -1996,11 +1905,7 @@ class binary_reader
    {
        if (get_char)
        {
-            // no get_ignore_noop() here: the byte read next must be a string
+            get();  // TODO(niels): may we ignore N here?
            // length type specification, and a no-op ('N') is not valid in
            // that position. No-ops at positions where a value may appear are
            // already consumed by the callers via get_ignore_noop().
            get();
        }
        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
@@ -2074,17 +1979,8 @@ class binary_reader
                break;
        }
        auto last_token = get_token_string();
-        std::string message;
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
-
+                                exception_message(input_format, unexpected_length_type_message(last_token, ""), "string"), nullptr));
        if (input_format != input_format_t::bjdata)
        {
            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
        }
        else
        {
            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
        }
        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
    }
    /*!
@@ -2363,17 +2259,8 @@ class binary_reader
                break;
        }
        auto last_token = get_token_string();
-        std::string message;
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
-
+                                exception_message(input_format, unexpected_length_type_message(last_token, " after '#'"), "size"), nullptr));
        if (input_format != input_format_t::bjdata)
        {
            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
        }
        else
        {
            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
        }
        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
    }
    /*!
@@ -2559,7 +2446,7 @@ class binary_reader
                const auto byte1 = static_cast<unsigned char>(byte1_raw);
                const auto byte2 = static_cast<unsigned char>(byte2_raw);
-                // Code from RFC 8949, Appendix D, Figure 3:
+                // Code from RFC 7049, Appendix D, Figure 3:
                // As half-precision floating-point numbers were only added
                // to IEEE 754 in 2008, today's programming platforms often
                // still only have limited support for them. It is very
@@ -2572,8 +2459,8 @@ class binary_reader
                {
                    const int exp = (half >> 10u) & 0x1Fu;
                    const unsigned int mant = half & 0x3FFu;
-                    JSON_ASSERT(exp <= 31);
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
-                    JSON_ASSERT(mant <= 1023);
+                    JSON_ASSERT(mant <= 1024);
                    switch (exp)
                    {
                        case 0:
@@ -2890,17 +2777,7 @@ class binary_reader
            case token_type::value_unsigned:
                return sax->number_unsigned(number_lexer.get_number_unsigned());
            case token_type::value_float:
-            {
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
                const auto parsed_float = number_lexer.get_number_float();
                if (JSON_HEDLEY_UNLIKELY(!std::isfinite(parsed_float)))
                {
                    return sax->parse_error(
                               chars_read,
                               number_string,
                               out_of_range::create(406, concat("number overflow parsing '", number_string, '\''), nullptr));
                }
                return sax->number_float(parsed_float, std::move(number_string));
            }
            case token_type::uninitialized:
            case token_type::literal_true:
            case token_type::literal_false:
@@ -345,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;
            }
        }
@@ -370,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;
                }
@@ -628,7 +626,14 @@ class json_sax_dom_callback_parser
        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
        {
            // remove discarded value
-            remove_discarded_value(*ref_stack.back());
+            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;
@@ -669,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)
@@ -705,19 +709,9 @@ class json_sax_dom_callback_parser
        keep_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());
            }
        }
        return true;
@@ -771,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;
                }
@@ -809,19 +801,6 @@ class json_sax_dom_callback_parser
    }
 #endif
    /// remove the discarded value the callback rejected from its parent
    static void remove_discarded_value(BasicJsonType& parent)
    {
        for (auto it = parent.begin(); it != parent.end(); ++it)
        {
            if (it->is_discarded())
            {
                parent.erase(it);
                break;
            }
        }
    }
    /*!
    @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
@@ -862,18 +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());
                const bool placeholder_stored = key_keep_stack.back();
                key_keep_stack.pop_back();
                if (placeholder_stored)
                {
                    remove_discarded_value(*ref_stack.back());
                }
            }
            return {false, nullptr};
        }
@@ -1357,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> {});
    }
@@ -1524,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
    {
@@ -1733,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 {};
@@ -186,15 +186,6 @@
    #define JSON_NO_UNIQUE_ADDRESS
 #endif
 // Clang targeting MinGW does not survive the thread_local storage the copy
 // constructor uses to bound its descent: every test that copies a value
 // segfaults with clang 11.0.1 and clang 18.1.8, while the same tests pass with
 // GCC targeting MinGW and with every other toolchain the library is tested on.
 // Copying works the same way without the counter, only more slowly.
 #if !defined(JSON_NO_THREAD_LOCAL) && defined(__clang__) && defined(__MINGW32__)
    #define JSON_NO_THREAD_LOCAL 1
 #endif
 // disable documentation warnings on clang
 #if defined(__clang__)
    #pragma clang diagnostic push
@@ -231,9 +231,7 @@ struct char_traits<signed char> : std::char_traits<char>
    // Redefine to_int_type function
    static int_type to_int_type(char_type c) noexcept
    {
-        // cast via unsigned char: sign-extending a negative char_type would make
+        return static_cast<int_type>(c);
        // byte 0xFF indistinguishable from eof()
        return static_cast<int_type>(static_cast<unsigned char>(c));
    }
    static char_type to_char_type(int_type i) noexcept
@@ -701,34 +699,20 @@ struct is_json_pointer_of<A, ::nlohmann::json_pointer<A>> : std::true_type {};
 template <typename A>
 struct is_json_pointer_of<A, ::nlohmann::json_pointer<A>&> : std::true_type {};
 // checks if A and B are comparable using Compare functor, assuming that
 // neither A nor B is a json_pointer type (that case is handled by
 // is_comparable below, which never instantiates this helper otherwise)
 template<typename Compare, typename A, typename B, typename = void>
 struct is_comparable_no_json_pointer : std::false_type {};
 template<typename Compare, typename A, typename B>
 struct is_comparable_no_json_pointer < Compare, A, B, enable_if_t <
 std::is_constructible <decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>()))>::value
 && std::is_constructible <decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))>::value
 >> : std::true_type {};
 // checks if A and B are comparable using Compare functor
-// We dispatch on is_json_pointer_of as a plain bool (rather than folding it
+template<typename Compare, typename A, typename B, typename = void>
 // into a single enable_if_t condition together with the checks below) so
 // that the Compare(A, B) checks are only ever written - and thus only ever
 // instantiated - when A/B are not a json_pointer/string pair. Those checks
 // use json_pointer::operator string_t() (GCC, see #4621) resp. the
 // deprecated json_pointer/string operator== (Clang, see #5288), and merely
 // naming them as later operands of a plain && chain is not sufficient to
 // avoid their instantiation on all compilers, even when the first operand
 // is false. The dispatch on is_json_pointer_of can be removed once the
 // deprecated json_pointer comparison operators have been removed.
 template<typename Compare, typename A, typename B, bool = is_json_pointer_of<A, B>::value>
 struct is_comparable : std::false_type {};
 // We exclude json_pointer here, because the checks using Compare(A, B) will
 // use json_pointer::operator string_t() which triggers a deprecation warning
 // for GCC. See https://github.com/nlohmann/json/issues/4621. The call to
 // is_json_pointer_of can be removed once the deprecated function has been
 // removed.
 template<typename Compare, typename A, typename B>
-struct is_comparable<Compare, A, B, false> : is_comparable_no_json_pointer<Compare, A, B> {};
+struct is_comparable < Compare, A, B, enable_if_t < !is_json_pointer_of<A, B>::value
 && std::is_constructible <decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>()))>::value
 && std::is_constructible <decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))>::value
 >> : std::true_type {};
 template<typename T>
 using detect_is_transparent = typename T::is_transparent;
@@ -979,28 +979,13 @@ class binary_writer
        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
    }
    /*!
    @brief Checks that @a size fits into the 32-bit length field used by BSON
    @return The size as a signed 32-bit integer
    @throw out_of_range.412 if @a size exceeds the range of std::int32_t
    */
    static std::int32_t to_bson_length(const std::size_t size)
    {
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::int32_t>(size)))
        {
            JSON_THROW(out_of_range::create(412, concat("BSON length ", std::to_string(size), " exceeds maximum of ", std::to_string((std::numeric_limits<std::int32_t>::max)())), nullptr));
        }
        return static_cast<std::int32_t>(size);
    }
    /*!
    @brief Writes the given @a element_type and @a name to the output adapter
    */
    void write_bson_entry_header(const string_t& name,
                                 const std::uint8_t element_type)
    {
-        oa->write_character(to_char_type(element_type));
+        oa->write_character(to_char_type(element_type)); // boolean
        oa->write_characters(
            reinterpret_cast<const CharType*>(name.c_str()),
            name.size() + 1u);
@@ -1042,7 +1027,7 @@ class binary_writer
    {
        write_bson_entry_header(name, 0x02);
-        write_number<std::int32_t>(to_bson_length(value.size() + 1ul), true);
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
        oa->write_characters(
            reinterpret_cast<const CharType*>(value.c_str()),
            value.size() + 1);
@@ -1085,7 +1070,7 @@ class binary_writer
    }
    /*!
-    @return The size of the BSON-encoded unsigned integer @a value
+    @return The size of the BSON-encoded unsigned integer in @a j
    */
    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
    {
@@ -1098,22 +1083,22 @@ class binary_writer
    @brief Writes a BSON element with key @a name and unsigned @a value
    */
    void write_bson_unsigned(const string_t& name,
-                             const std::uint64_t value)
+                             const BasicJsonType& j)
    {
-        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
        {
            write_bson_entry_header(name, 0x10 /* int32 */);
-            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
        }
-        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
        {
            write_bson_entry_header(name, 0x12 /* int64 */);
-            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
        }
        else
        {
            write_bson_entry_header(name, 0x11 /* uint64 */);
-            write_number<std::uint64_t>(value, true);
+            write_number<std::uint64_t>(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned), true);
        }
    }
@@ -1157,7 +1142,7 @@ class binary_writer
                          const typename BasicJsonType::array_t& value)
    {
        write_bson_entry_header(name, 0x04); // array
-        write_number<std::int32_t>(to_bson_length(calc_bson_array_size(value)), true);
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
        std::size_t array_index = 0ul;
@@ -1177,7 +1162,7 @@ class binary_writer
    {
        write_bson_entry_header(name, 0x05);
-        write_number<std::int32_t>(to_bson_length(value.size()), true);
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
@@ -1259,7 +1244,7 @@ class binary_writer
                return write_bson_integer(name, j.m_data.m_value.number_integer);
            case value_t::number_unsigned:
-                return write_bson_unsigned(name, j.m_data.m_value.number_unsigned);
+                return write_bson_unsigned(name, j);
            case value_t::string:
                return write_bson_string(name, *j.m_data.m_value.string);
@@ -1299,7 +1284,7 @@ class binary_writer
    */
    void write_bson_object(const typename BasicJsonType::object_t& value)
    {
-        write_number<std::int32_t>(to_bson_length(calc_bson_object_size(value)), true);
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
        for (const auto& el : value)
        {
@@ -1662,31 +1647,7 @@ class binary_writer
        std::size_t len = (value.at(key).empty() ? 0 : 1);
        for (const auto& el : value.at(key))
        {
-            // a dimension is read as an unsigned value below, so anything that
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
            // is not a non-negative integer is rejected: a non-integer entry
            // would pun unrelated bytes as the dimension, and a negative one
            // would wrap into a nonsensical length
            if (!el.is_number_integer() || (!el.is_number_unsigned() && el.template get<std::int64_t>() < 0))
            {
                return true;
            }
            // a dimension that does not fit into std::size_t, or a product that
            // overflows it, would wrap around and could match the size of
            // _ArrayData_ by accident; the resulting header announces an
            // element count that no reader can honor (the binary reader rejects
            // it with out_of_range.408), so encode as a plain object instead
            const auto dim = el.template get<std::uint64_t>();
            if (!value_in_range_of<std::size_t>(dim))
            {
                return true;
            }
            const auto dim_size = static_cast<std::size_t>(dim);
            if (dim_size != 0 && len > (std::numeric_limits<std::size_t>::max)() / dim_size)
            {
                return true;
            }
            len *= dim_size;
        }
        key = "_ArrayData_";
@@ -1695,24 +1656,6 @@ class binary_writer
            return true;
        }
        // every element is written below as the number kind dtype names, so it
        // has to actually be a number of that category: an element of any other
        // type would reinterpret unrelated bytes, e.g. a string's heap pointer,
        // as that number. Such an object falls back to a plain object encoding.
        // dtype names the wire type, not the storage type: whether an integer
        // is held as number_integer or number_unsigned depends on how the value
        // was built (parsing stores non-negative integers as unsigned, the C++
        // API stores int literals as signed), so both are accepted here and the
        // writes below go through get<>, which reads the member that is active.
        const bool ndarray_is_float = (dtype == 'd' || dtype == 'D');
        for (const auto& el : value.at(key))
        {
            if (ndarray_is_float ? !el.is_number_float() : !el.is_number_integer())
            {
                return true;
            }
        }
        oa->write_character('[');
        oa->write_character('$');
        oa->write_character(dtype);
@@ -1726,70 +1669,70 @@ class binary_writer
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::uint8_t>(el.template get<std::uint64_t>()), true);
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'i')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::int8_t>(el.template get<std::int64_t>()), true);
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'u')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::uint16_t>(el.template get<std::uint64_t>()), true);
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'I')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::int16_t>(el.template get<std::int64_t>()), true);
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'm')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::uint32_t>(el.template get<std::uint64_t>()), true);
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'l')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<std::int32_t>(el.template get<std::int64_t>()), true);
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'M')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(el.template get<std::uint64_t>(), true);
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
            }
        }
        else if (dtype == 'L')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(el.template get<std::int64_t>(), true);
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
            }
        }
        else if (dtype == 'd')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(static_cast<float>(el.template get<double>()), true);
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
            }
        }
        else if (dtype == 'D')
        {
            for (const auto& el : value.at(key))
            {
-                write_number(el.template get<double>(), true);
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
            }
        }
        return false;
@@ -28,14 +28,14 @@
    #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif
-#include <algorithm> // all_of, find, for_each, none_of
+#include <algorithm> // all_of, find, for_each
 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
 #include <functional> // hash, less
 #include <initializer_list> // initializer_list
 #ifndef JSON_NO_IO
    #include <iosfwd> // istream, ostream
 #endif  // JSON_NO_IO
-#include <iterator> // make_move_iterator, random_access_iterator_tag
+#include <iterator> // random_access_iterator_tag
 #include <memory> // unique_ptr
 #include <string> // string, stoi, to_string
 #include <utility> // declval, forward, move, pair, swap
@@ -821,626 +821,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return j;
    }
    /// the number of levels an operation descends into before it finishes the
    /// value below it without the call stack
    static constexpr std::size_t nesting_depth_limit()
    {
        return 128;
    }
 #ifndef JSON_NO_THREAD_LOCAL
    /*!
    @brief how many levels the operation going on in this thread has descended into
    Copying a value and comparing two values share this count. The library never
    nests one inside the other - copying a value does not compare one, and
    comparing two values does not copy them - and where user code nests them
    anyway, sharing the count only ends a descent sooner than it had to, which
    costs a little speed and is never wrong.
    A byte is enough: the count never exceeds the limit by more than the single
    level that notices the limit has been reached.
    */
    static std::size_t& nesting_depth() noexcept
    {
        static thread_local std::size_t depth = 0; // NOLINT(misc-use-internal-linkage)
        return depth;
    }
 #endif
    /*!
    @brief whether a descent must stop here and finish without the call stack
    @a may_descend says whether the operator descends at all; it is a constant
    at every call site, and is passed rather than tested by the caller so that
    the test does not become a constant condition there, which MSVC reports as
    C4127.
    */
    static bool nesting_depth_exhausted(bool may_descend = true) noexcept
    {
 #ifdef JSON_NO_THREAD_LOCAL
        // without a count of its own per thread, a descent cannot be bounded
        // without racing another one, so none is made
        static_cast<void>(may_descend);
        return true;
 #else
        return !may_descend || nesting_depth() >= nesting_depth_limit();
 #endif
    }
    /*!
    @brief counts one level of a bounded descent for as long as it runs
    The constructor taking the count is for callers that have looked it up
    already to test it: reaching thread-local storage is not free, and the path
    that is taken almost every time should reach it once rather than twice. The
    other is for callers that cannot look it up - the comparison operators are
    written as a macro, and a macro cannot use the preprocessor.
    */
    class nesting_depth_guard
    {
      public:
        explicit nesting_depth_guard(std::size_t& depth) noexcept
            : m_depth(&depth)
        {
            ++*m_depth;
        }
        nesting_depth_guard() noexcept
            : m_depth(countable())
        {
            if (m_depth != nullptr)
            {
                ++*m_depth;
            }
        }
        ~nesting_depth_guard()
        {
            if (m_depth != nullptr)
            {
                --*m_depth;
            }
        }
        nesting_depth_guard(const nesting_depth_guard&) = delete;
        nesting_depth_guard& operator=(const nesting_depth_guard&) = delete;
        nesting_depth_guard(nesting_depth_guard&&) = delete;
        nesting_depth_guard& operator=(nesting_depth_guard&&) = delete;
      private:
        /// @brief the count to keep, or nullptr where there is none to keep
        static std::size_t* countable() noexcept
        {
 #ifdef JSON_NO_THREAD_LOCAL
            return nullptr;
 #else
            return &nesting_depth();
 #endif
        }
        std::size_t* m_depth;
    };
    /// an entry of the iterative deep copy's worklist: a structured value and
    /// the value that is to become its copy
    using copy_worklist_t = std::vector<std::pair<const basic_json*, basic_json*>>;
    /// scratch space to build the key skeleton of an object copy in one go
    using copy_scratch_t = std::vector<std::pair<typename object_t::key_type, basic_json>>;
    /// @brief copy everything of @a src into @a dst but its type and value
    static void copy_metadata(const basic_json& src, basic_json& dst)
    {
        // a custom base class is only required to be copy-constructible and
        // move-assignable, so the copy has to go through a temporary
        static_cast<json_base_class_t&>(dst) = json_base_class_t(static_cast<const json_base_class_t&>(src));
 #if JSON_DIAGNOSTIC_POSITIONS
        dst.start_position = src.start_position;
        dst.end_position = src.end_position;
 #else
        static_cast<void>(src);
        static_cast<void>(dst);
 #endif
    }
    /*!
    @brief copy the value of @a src into @a dst, which must not be structured
    Objects and arrays are left alone: creating those is the one thing the copy
    constructor and @ref copy_shallow do differently from one another, and it is
    the reason copying a value can descend at all.
    */
    /// @note inlined on purpose: both callers have already told an object or an
    ///       array apart from the rest, and letting the compiler fold that test
    ///       into this switch is worth a few percent when copying a value made
    ///       mostly of numbers
    JSON_HEDLEY_ALWAYS_INLINE
    static void copy_leaf_value(const basic_json& src, basic_json& dst)
    {
        switch (src.m_data.m_type)
        {
            case value_t::string:
            {
                dst.m_data.m_value = *src.m_data.m_value.string;
                break;
            }
            case value_t::binary:
            {
                dst.m_data.m_value = *src.m_data.m_value.binary;
                break;
            }
            case value_t::boolean:
            {
                dst.m_data.m_value = src.m_data.m_value.boolean;
                break;
            }
            case value_t::number_integer:
            {
                dst.m_data.m_value = src.m_data.m_value.number_integer;
                break;
            }
            case value_t::number_unsigned:
            {
                dst.m_data.m_value = src.m_data.m_value.number_unsigned;
                break;
            }
            case value_t::number_float:
            {
                dst.m_data.m_value = src.m_data.m_value.number_float;
                break;
            }
            case value_t::object:
            case value_t::array:
            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }
    }
    /*!
    @brief copy everything of @a src into the null value @a dst but the children
    Objects and arrays are not copied here; they are appended to @a worklist to
    be created later by @ref copy_iteratively. Until that happens, @a dst remains
    a null value, so that a partially built copy can be destroyed at any point
    without ever violating the class invariants.
    */
    static void copy_shallow(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
    {
        copy_metadata(src, dst);
        if (src.m_data.m_type == value_t::object || src.m_data.m_type == value_t::array)
        {
            // defer: dst stays a null value until its container exists
            worklist.emplace_back(&src, &dst);
            return;
        }
        copy_leaf_value(src, dst);
        // only now that the value exists may the type be set: had the creation
        // of the value thrown, dst would have been left as a valid null value
        dst.m_data.m_type = src.m_data.m_type;
    }
    /// @brief create the copy of the array @a src in @a dst
    /// @note structured elements are appended to @a worklist instead
    static void copy_array_level(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
    {
        const array_t& src_array = *src.m_data.m_value.array;
        // create all elements up front: growing the array afterwards could
        // invalidate the pointers that are handed to the worklist
        dst.m_data.m_value.array = create<array_t>(src_array.size(), basic_json());
        auto dst_it = dst.m_data.m_value.array->begin();
        for (auto src_it = src_array.cbegin(); src_it != src_array.cend(); ++src_it, ++dst_it)
        {
            copy_shallow(*src_it, *dst_it, worklist);
        }
    }
    /// @brief create the copy of the object @a src in @a dst
    /// @note structured values are appended to @a worklist instead
    static void copy_object_level(const basic_json& src, basic_json& dst,
                                  copy_worklist_t& worklist, copy_scratch_t& scratch)
    {
        const object_t& src_object = *src.m_data.m_value.object;
        // build the complete key skeleton and hand it to the object's range
        // constructor: adding the keys one by one would be quadratic for object
        // types that are backed by a vector, such as nlohmann::ordered_map
        scratch.clear();
        scratch.reserve(src_object.size());
        for (const auto& element : src_object)
        {
            scratch.emplace_back(element.first, basic_json());
        }
        dst.m_data.m_value.object = create<object_t>(std::make_move_iterator(scratch.begin()),
                                    std::make_move_iterator(scratch.end()));
        scratch.clear();
        // pair every value of the copy with its counterpart in the original;
        // both are enumerated in the same order for every object type with a
        // deterministic order, so the lookup is only needed for exotic ones
        auto src_it = src_object.cbegin();
        for (auto& element : *dst.m_data.m_value.object)
        {
            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
            {
                copy_shallow(src_it->second, element.second, worklist);
                ++src_it;
            }
            else
            {
                const auto found = src_object.find(element.first);
                JSON_ASSERT(found != src_object.cend());
                copy_shallow(found->second, element.second, worklist);
            }
        }
    }
    /*!
    @brief deep-copy the object or array @a src into this value without recursing
    The values whose copy has not been created yet are kept on an explicit
    worklist rather than on the call stack. This is only reached for values
    nested deeper than @ref nesting_depth_limit levels, which is why it copies
    every container by hand instead of letting the container do it: the fast
    ways of doing so would descend into the elements and defeat the purpose.
    */
    void copy_iteratively(const basic_json& src)
    {
        copy_worklist_t worklist;
        copy_scratch_t scratch;
        const basic_json* src_value = &src;
        basic_json* dst_value = this;
        for (;;)
        {
            if (src_value->m_data.m_type == value_t::array)
            {
                copy_array_level(*src_value, *dst_value, worklist);
            }
            else
            {
                copy_object_level(*src_value, *dst_value, worklist, scratch);
            }
            // the container is complete and will not be modified again
            dst_value->set_parents();
            if (worklist.empty())
            {
                break;
            }
            const auto& next = worklist.back();
            src_value = next.first;
            dst_value = next.second;
            worklist.pop_back();
            // the value stops being a null value exactly here
            dst_value->m_data.m_type = src_value->m_data.m_type;
        }
    }
    /*!
    @brief copy one level of the object or array @a src into this value
    The container copies its own elements, which is the fastest way to fill it.
    Every element that is structured itself comes back to @ref copy_structured.
    */
    void copy_level(const basic_json& src)
    {
        if (m_data.m_type == value_t::object)
        {
            m_data.m_value = *src.m_data.m_value.object;
        }
        else
        {
            m_data.m_value = *src.m_data.m_value.array;
        }
        set_parents();
    }
    /*!
    @brief deep-copy the object or array @a src into this value
    Copying a container copies its elements, so a value nested deeply enough
    used to exhaust the call stack. The descent is bounded here: the first
    @ref nesting_depth_limit levels are copied by the containers themselves, just
    as they always were, and anything below that is copied without the call
    stack by @ref copy_iteratively. Copying a value can therefore no longer
    exhaust the stack, however deeply it is nested, just like destroying one
    cannot since #1436.
    Nothing has to be scanned or built by hand to reach that: a value that is
    not nested deeper than the limit - all but a vanishing minority - is copied
    exactly as it was before, and this whole detour costs it one counter.
    @sa https://github.com/nlohmann/json/issues/5387
    */
    void copy_structured(const basic_json& src)
    {
 #ifndef JSON_NO_THREAD_LOCAL
        std::size_t& depth = nesting_depth();
        if (JSON_HEDLEY_LIKELY(depth < nesting_depth_limit()))
        {
            const nesting_depth_guard guard(depth);
            copy_level(src);
            return;
        }
 #endif
        // Finish this value without descending any further. It is completed
        // before this returns, so a copy made by a custom base class - or by
        // anything else that runs while a copy is going on - is unaffected by
        // the copy it is nested in.
        copy_iteratively(src);
    }
    /// the result of comparing two values, including values that cannot be
    /// ordered at all, such as a discarded value or a NaN
    enum class compare_result { less, equal, greater, unordered };
 #if JSON_HAS_THREE_WAY_COMPARISON
    /// @brief the ordering that @a result stands for
    static std::partial_ordering to_partial_ordering(compare_result result) noexcept // *NOPAD*
    {
        switch (result)
        {
            case compare_result::less:
                return std::partial_ordering::less;
            case compare_result::greater:
                return std::partial_ordering::greater;
            case compare_result::equal:
                return std::partial_ordering::equivalent;
            case compare_result::unordered:
            default:
                return std::partial_ordering::unordered;
        }
    }
 #endif
    /*!
    @brief compare two values that are not both an array or both an object
    Such a pair is compared by the operators themselves, which cannot descend
    into it and therefore cannot recurse.
    That holds for a pair whose types differ as much as for a pair of leaves: an
    array and an object are told apart by their types alone, because an operator
    only ever descends into two values of the same type. So `==` reports them as
    unequal without looking inside either, and an ordering falls back to the
    order of the types - an object sorts before an array - exactly as it does
    for a value that is not nested deeply enough to get here.
    */
    template<bool Ordered>
    static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
    {
        if (lhs == rhs)
        {
            return compare_result::equal;
        }
        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
    }
    /*!
    @brief compare two object keys
    An object compares its entries as pairs of a key and a value, so its keys
    are compared exactly as std::pair compares them: with < where the objects
    are being ordered, and with == where they are only checked for equality.
    Note that this is not the object's own comparator, which for a vector-backed
    object type such as nlohmann::ordered_map tells equality rather than order.
    */
    static compare_result compare_keys(const typename object_t::key_type& lhs,
                                       const typename object_t::key_type& rhs,
                                       std::true_type /*ordered*/)
    {
        if (lhs < rhs)
        {
            return compare_result::less;
        }
        if (rhs < lhs)
        {
            return compare_result::greater;
        }
        return compare_result::equal;
    }
    /// @brief check two object keys for equality
    static compare_result compare_keys(const typename object_t::key_type& lhs,
                                       const typename object_t::key_type& rhs,
                                       std::false_type /*ordered*/)
    {
        return lhs == rhs ? compare_result::equal : compare_result::unordered;
    }
    /// @brief tell apart two values that are not equal
    /// @note only instantiated where the values are being ordered, as a key or
    ///       string type is not required to be ordered to be compared for equality
    static compare_result order_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
    {
        if (lhs < rhs)
        {
            return compare_result::less;
        }
        if (rhs < lhs)
        {
            return compare_result::greater;
        }
        return compare_result::unordered;
    }
    /// @brief report two values as not equal without ordering them
    static compare_result order_leaves(const_reference /*lhs*/, const_reference /*rhs*/, std::false_type /*ordered*/) noexcept
    {
        return compare_result::unordered;
    }
    /*!
    @brief compare @a lhs and @a rhs without descending into them
    Reached once a comparison has descended @ref nesting_depth_limit levels, so
    that comparing values cannot exhaust the call stack however deeply they are
    nested. The two values are walked in lockstep on an explicit stack and
    compared lexicographically, element by element in the order the containers
    enumerate them - which is how the container types this library ships compare
    themselves: a std::map enumerates its entries in key order, and
    nlohmann::ordered_map in insertion order. An object type that enumerates its
    entries in an unspecified order, such as std::unordered_map, compares them
    pairwise instead; the difference could only ever show below the bound.
    Note that the stack this walks with is allocated, while the comparison
    operators are noexcept and the container comparison this replaces allocated
    nothing. Failing that allocation therefore ends the process rather than
    throwing. It only arises for values nested past the bound, and only when
    memory has run out - where the same comparison used to exhaust the call
    stack instead - but it is a way to fail that the operators did not have.
    */
    template<bool Ordered>
    static compare_result compare_iteratively(const_reference lhs, const_reference rhs,
            const bool unordered_compares_equal) noexcept
    {
        /// a pair of containers being compared in lockstep
        struct frame
        {
            const basic_json* lhs_value{nullptr};
            const basic_json* rhs_value{nullptr};
            typename array_t::const_iterator lhs_array_it{};
            typename array_t::const_iterator rhs_array_it{};
            typename object_t::const_iterator lhs_object_it{};
            typename object_t::const_iterator rhs_object_it{};
        };
        std::vector<frame> stack;
        const basic_json* left = &lhs;
        const basic_json* right = &rhs;
        for (;;)
        {
            const auto type = left->m_data.m_type;
            if (type == right->m_data.m_type && (type == value_t::array || type == value_t::object))
            {
                // descend: the elements decide, and are compared further down
                stack.emplace_back();
                frame& pushed = stack.back();
                pushed.lhs_value = left;
                pushed.rhs_value = right;
                if (type == value_t::array)
                {
                    pushed.lhs_array_it = left->m_data.m_value.array->cbegin();
                    pushed.rhs_array_it = right->m_data.m_value.array->cbegin();
                }
                else
                {
                    pushed.lhs_object_it = left->m_data.m_value.object->cbegin();
                    pushed.rhs_object_it = right->m_data.m_value.object->cbegin();
                }
            }
            else
            {
                const compare_result result = compare_leaves<Ordered>(*left, *right);
                // Values that cannot be ordered - a NaN, say - end an ordered
                // comparison for std::lexicographical_compare_three_way, but
                // std::lexicographical_compare treats them as equivalent and
                // carries on with the next element. Both are reproduced here,
                // so that a value nested too deeply to descend into compares
                // exactly as one that is not.
                if (result != compare_result::equal &&
                        !(unordered_compares_equal && result == compare_result::unordered))
                {
                    return result;
                }
            }
            // walk back up past the containers that are exhausted, then take the
            // next pair of elements from the innermost one that is not
            for (;;)
            {
                if (stack.empty())
                {
                    return compare_result::equal;
                }
                frame& current = stack.back();
                const bool is_object = current.lhs_value->m_data.m_type == value_t::object;
                const bool lhs_done = is_object
                                      ? current.lhs_object_it == current.lhs_value->m_data.m_value.object->cend()
                                      : current.lhs_array_it == current.lhs_value->m_data.m_value.array->cend();
                const bool rhs_done = is_object
                                      ? current.rhs_object_it == current.rhs_value->m_data.m_value.object->cend()
                                      : current.rhs_array_it == current.rhs_value->m_data.m_value.array->cend();
                if (lhs_done || rhs_done)
                {
                    // whichever ran out first holds the smaller container; if
                    // both did, they are equal and the container above decides
                    if (lhs_done != rhs_done)
                    {
                        return lhs_done ? compare_result::less : compare_result::greater;
                    }
                    stack.pop_back();
                    continue;
                }
                if (is_object)
                {
                    // an entry is a key and a value, and the key decides first
                    const compare_result key_result =
                        compare_keys(current.lhs_object_it->first, current.rhs_object_it->first,
                                     std::integral_constant<bool, Ordered> {});
                    if (key_result != compare_result::equal)
                    {
                        return key_result;
                    }
                    left = &(current.lhs_object_it->second);
                    right = &(current.rhs_object_it->second);
                    ++current.lhs_object_it;
                    ++current.rhs_object_it;
                }
                else
                {
                    left = &(*current.lhs_array_it);
                    right = &(*current.rhs_array_it);
                    ++current.lhs_array_it;
                    ++current.rhs_array_it;
                }
                break;
            }
        }
    }
  public:
    //////////////////////////
    // JSON parser callback //
@@ -1820,15 +1200,60 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // check of passed value is valid
        other.assert_invariant();
-        if (m_data.m_type == value_t::object || m_data.m_type == value_t::array)
+        switch (m_data.m_type)
        {
-            // copying the container directly would call this constructor again
+            case value_t::object:
-            // for every element, once per nesting level
+            {
-            copy_structured(other);
+                m_data.m_value = *other.m_data.m_value.object;
-        }
+                break;
-        else
+            }
-        {
+
-            copy_leaf_value(other, *this);
+            case value_t::array:
            {
                m_data.m_value = *other.m_data.m_value.array;
                break;
            }
            case value_t::string:
            {
                m_data.m_value = *other.m_data.m_value.string;
                break;
            }
            case value_t::boolean:
            {
                m_data.m_value = other.m_data.m_value.boolean;
                break;
            }
            case value_t::number_integer:
            {
                m_data.m_value = other.m_data.m_value.number_integer;
                break;
            }
            case value_t::number_unsigned:
            {
                m_data.m_value = other.m_data.m_value.number_unsigned;
                break;
            }
            case value_t::number_float:
            {
                m_data.m_value = other.m_data.m_value.number_float;
                break;
            }
            case value_t::binary:
            {
                m_data.m_value = *other.m_data.m_value.binary;
                break;
            }
            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }
        set_parents();
@@ -4227,13 +3652,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    // note parentheses around operands are necessary; see
    // https://github.com/nlohmann/json/issues/1530
-    // Mixed signed/unsigned integer comparisons check whether the signed value
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
    // is negative before casting. If it is, the comparison is performed with
    // the fixed values -1 and 1, which preserves the ordering relationship
    // because any negative signed value is smaller than any unsigned value.
    // Otherwise, the non-negative signed value is cast to unsigned before the
    // comparison to avoid wraparound.
 #define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result, deep_result, may_descend) \
    const auto lhs_type = lhs.type();                                                                    \
    const auto rhs_type = rhs.type();                                                                    \
    \
@@ -4242,25 +3661,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        switch (lhs_type)                                                                                \
        {                                                                                                \
            case value_t::array:                                                                         \
            {                                                                                            \
                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
                {                                                                                        \
                    return (deep_result);                                                                \
                }                                                                                        \
                const nesting_depth_guard guard;                                                         \
                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
-            }                                                                                            \
+                \
            \
            case value_t::object:                                                                        \
            {                                                                                            \
                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
                {                                                                                        \
                    return (deep_result);                                                                \
                }                                                                                        \
                const nesting_depth_guard guard;                                                         \
                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
-            }                                                                                            \
+                \
            \
            case value_t::null:                                                                          \
                return (null_result);                                                                    \
                \
@@ -4305,16 +3710,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
    {                                                                                                    \
-        return (rhs.m_data.m_value.number_integer < 0)                                                   \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
               ? (number_integer_t(1) op number_integer_t(-1))                                           \
               : (lhs.m_data.m_value.number_unsigned op static_cast<number_unsigned_t>(rhs.m_data.m_value.number_integer)); \
    }                                                                                                    \
    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
    {                                                                                                    \
-        return (lhs.m_data.m_value.number_integer < 0)                                                   \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
-               ? (number_integer_t(-1) op number_integer_t(1))                                           \
+    }                                                                                                    \
               : (static_cast<number_unsigned_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_unsigned); \
    }                                                                                             \
    else if(compares_unordered(lhs, rhs))\
    {\
        return (unordered_result);\
@@ -4360,8 +3761,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        const_reference lhs = *this;
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
@@ -4386,8 +3786,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
                                std::partial_ordering::equivalent,
                                std::partial_ordering::unordered,
-                                lhs_type <=> rhs_type, // *NOPAD*
+                                lhs_type <=> rhs_type) // *NOPAD*
                                to_partial_ordering(compare_iteratively<true>(lhs, rhs, false)), true)
    }
    /// @brief comparison: 3-way
@@ -4454,8 +3853,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
@@ -4511,8 +3909,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // default_result is used if we cannot compare values. In that case,
        // we compare types. Note we have to call the operator explicitly,
        // because MSVC has problems otherwise.
-        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type),
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
                                 compare_iteratively<true>(lhs, rhs, true) == compare_result::less, false)
    }
    /// @brief comparison: less than
@@ -132,37 +132,3 @@ TEST_CASE("BJData")
        }
    }
 }
 TEST_CASE("CBOR")
 {
    SECTION("parse errors")
    {
        SECTION("array/map size larger than std::size_t")
        {
            // declared lengths do not fit in a 32-bit std::size_t and must not be truncated
            std::vector<uint8_t> const varr = {0x9B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05};
            std::vector<uint8_t> const vmap = {0xBB, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05};
            json _;
            CHECK_THROWS_WITH_AS(_ = json::from_cbor(varr), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive array size", json::out_of_range&);
            CHECK(json::from_cbor(varr, true, false).is_discarded());
            CHECK_THROWS_WITH_AS(_ = json::from_cbor(vmap), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size", json::out_of_range&);
            CHECK(json::from_cbor(vmap, true, false).is_discarded());
        }
        SECTION("array/map size equal to the indefinite-length sentinel")
        {
            // on 32-bit platforms a four-byte length of 0xFFFFFFFF aliases unknown_size()
            std::vector<uint8_t> const varr = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
            std::vector<uint8_t> const vmap = {0xBA, 0xFF, 0xFF, 0xFF, 0xFF};
            json _;
            CHECK_THROWS_WITH_AS(_ = json::from_cbor(varr), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive array size", json::out_of_range&);
            CHECK(json::from_cbor(varr, true, false).is_discarded());
            CHECK_THROWS_WITH_AS(_ = json::from_cbor(vmap), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size", json::out_of_range&);
            CHECK(json::from_cbor(vmap, true, false).is_discarded());
        }
    }
 }
@@ -216,57 +216,6 @@ TEST_CASE("controlled bad_alloc")
            CHECK_THROWS_AS(my_json(s), std::bad_alloc&);
            next_construct_fails = false;
        }
        SECTION("basic_json(const basic_json&) of a deeply nested value (#5387)")
        {
            // Copying a value nested deeper than the descent bound builds the
            // copy from the top down: every value whose own copy has not been
            // made yet stays a null value until it is. Failing an allocation
            // part-way through is what proves such a half-built copy can still
            // be destroyed.
            //
            // Which path the failure lands in depends on the build: the first
            // allocation of a copy belongs to the outermost level, so here it
            // is the descending one. Built with JSON_NO_THREAD_LOCAL - as the
            // ci_test_no_thread_local target builds the whole suite - no
            // descent is made at all and the very same failure lands in the
            // iterative path instead, part-way through its worklist.
            const auto check_deep_copy = [](bool objects)
            {
                CAPTURE(objects);
                next_construct_fails = false;
                // deeper than the 128 levels the copy constructor descends into
                const std::size_t depth = 300;
                my_json j = 1;
                for (std::size_t i = 0; i < depth; ++i)
                {
                    if (objects)
                    {
                        my_json wrapper = my_json::object();
                        wrapper["a"] = std::move(j);
                        j = std::move(wrapper);
                    }
                    else
                    {
                        j = my_json::array({std::move(j)});
                    }
                }
                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
                CHECK_NOTHROW(my_json(j));
                next_construct_fails = true;
                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
                CHECK_THROWS_AS(my_json(j), std::bad_alloc&);
                next_construct_fails = false;
            };
            check_deep_copy(false);
            check_deep_copy(true);
        }
    }
 }
@@ -1347,8 +1347,6 @@ TEST_CASE("BJData")
                    CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vec2), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing BJData high-precision number: invalid number text: 1A", json::parse_error);
                    std::vector<uint8_t> const vec3 = {'H', 'i', 2, '1', '.'};
                    CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vec3), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing BJData high-precision number: invalid number text: 1.", json::parse_error);
                    std::vector<uint8_t> const vec_overflow = {'H', 'i', 5, '1', 'e', '4', '0', '0'};
                    CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vec_overflow), "[json.exception.out_of_range.406] number overflow parsing '1e400'", json::out_of_range);
                    std::vector<uint8_t> const vec4 = {'H', 2, '1', '0'};
                    CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vec4), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing BJData size: expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x02", json::parse_error);
                }
@@ -2589,69 +2587,6 @@ TEST_CASE("BJData")
                CHECK(json::to_bjdata(json::from_bjdata(v_B), true, true) == v_B);
            }
            SECTION("ndarray with data not matching _ArrayType_ is written as an object")
            {
                // A JData-annotated object is only serialized as an ndarray when
                // its _ArrayData_ elements are actually stored as the number kind
                // named by _ArrayType_. Otherwise the writer would read the wrong
                // union member (e.g. a std::string's heap pointer as a uint64) and
                // emit it, so such an object falls back to a plain object encoding
                // that still round-trips.
                // string data declared as a uint64 array
                json const j_str = json({{"_ArrayType_", "uint64"}, {"_ArraySize_", {1}}, {"_ArrayData_", {"pointer"}}});
                const auto out_str = json::to_bjdata(j_str);
                CHECK(out_str.at(0) == '{');
                CHECK(json::from_bjdata(out_str) == j_str);
                // integer data declared as a double array
                json const j_float = json({{"_ArrayType_", "double"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
                const auto out_float = json::to_bjdata(j_float);
                CHECK(out_float.at(0) == '{');
                CHECK(json::from_bjdata(out_float) == j_float);
                // a non-integer shape entry is likewise not treated as an ndarray
                json const j_size = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {"x"}}, {"_ArrayData_", {1}}});
                const auto out_size = json::to_bjdata(j_size);
                CHECK(out_size.at(0) == '{');
                CHECK(json::from_bjdata(out_size) == j_size);
                // a negative shape entry is not a usable dimension either
                json const j_neg = json::parse(R"({"_ArrayType_":"uint8","_ArraySize_":[-1],"_ArrayData_":[1]})");
                const auto out_neg = json::to_bjdata(j_neg);
                CHECK(out_neg.at(0) == '{');
                CHECK(json::from_bjdata(out_neg) == j_neg);
            }
            SECTION("ndarray parsed from text is written as a typed array")
            {
                // json::parse stores a non-negative integer as number_unsigned while
                // the C++ API stores an int literal as number_integer, so _ArrayType_
                // names the wire type rather than the storage. Both storages have to
                // produce the same typed array for every type.
                for (const char* type :
                        {"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "char", "byte"
                        })
                {
                    CAPTURE(type);
                    const std::string text = std::string(R"({"_ArrayType_":")") + type +
                                             R"(","_ArraySize_":[2,3],"_ArrayData_":[1,2,3,4,5,6]})";
                    const auto from_text = json::to_bjdata(json::parse(text));
                    CHECK(from_text.at(0) == '[');
                    CHECK(from_text == json::to_bjdata(json({{"_ArrayType_", type}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}})));
                }
                // negative values under a signed type behave the same way
                const auto from_neg = json::to_bjdata(json::parse(R"({"_ArrayType_":"int32","_ArraySize_":[2],"_ArrayData_":[-5,7]})"));
                CHECK(from_neg.at(0) == '[');
                CHECK(from_neg == json::to_bjdata(json({{"_ArrayType_", "int32"}, {"_ArraySize_", {2}}, {"_ArrayData_", {-5, 7}}})));
                // and so do the floating point types
                const auto from_float = json::to_bjdata(json::parse(R"({"_ArrayType_":"double","_ArraySize_":[2],"_ArrayData_":[1.5,2.5]})"));
                CHECK(from_float.at(0) == '[');
                CHECK(from_float == json::to_bjdata(json({{"_ArrayType_", "double"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1.5, 2.5}}})));
            }
            SECTION("optimized ndarray (type and vector-size as 1D array)")
            {
                // create vector with two elements of the same type
@@ -2730,27 +2665,6 @@ TEST_CASE("BJData")
                CHECK(json::from_bjdata(json::to_bjdata(j_type), true, true) == j_type);
                CHECK(json::from_bjdata(json::to_bjdata(j_size), true, true) == j_size);
            }
            SECTION("ndarray whose dimensions overflow stays as object")
            {
                // the product of the dimensions wraps around std::size_t to 0
                // and so matches the size of the empty _ArrayData_; writing this
                // as an ndarray would announce an element count no reader can
                // honor, so it has to stay a plain object
                json j_overflow = json({{"_ArrayData_", json::array()}, {"_ArraySize_", {9223372036854775808ull, 2}}, {"_ArrayType_", "uint8"}});
                CHECK(json::from_bjdata(json::to_bjdata(j_overflow), true, true) == j_overflow);
                // a single dimension that does not fit into std::size_t is
                // rejected for the same reason (only observable where
                // std::size_t is narrower than 64 bit)
                json j_huge = json({{"_ArrayData_", json::array()}, {"_ArraySize_", {18446744073709551615ull}}, {"_ArrayType_", "uint8"}});
                CHECK(json::from_bjdata(json::to_bjdata(j_huge), true, true) == j_huge);
                // a well-formed ndarray is still encoded as one
                json j_ok = json({{"_ArrayData_", {1, 2, 3, 4, 5, 6}}, {"_ArraySize_", {2, 3}}, {"_ArrayType_", "uint8"}});
                CHECK(json::to_bjdata(j_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, 'i', 3, ']', 1, 2, 3, 4, 5, 6}));
                CHECK(json::from_bjdata(json::to_bjdata(j_ok), true, true) == j_ok);
            }
        }
    }
@@ -11,35 +11,12 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <cstdint>
 #include <fstream>
 #include <limits>
 #include <sstream>
 #include <vector>
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 namespace
 {
 // a binary container that reports a size beyond INT32_MAX without allocating
 // that much memory, so the BSON length overflow can be tested cheaply
 class huge_binary_t : public std::vector<std::uint8_t>
 {
  public:
    using std::vector<std::uint8_t>::vector;
    size_type size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
    {
        // one byte more than the BSON length field can represent
        return static_cast<size_type>((std::numeric_limits<std::int32_t>::max)()) + 1;
    }
 };
 using huge_binary_json = nlohmann::basic_json <
                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
                         double, std::allocator, nlohmann::adl_serializer, huge_binary_t, void >;
 } // namespace
 TEST_CASE("BSON")
 {
    SECTION("individual values not supported")
@@ -103,14 +80,6 @@ TEST_CASE("BSON")
 #endif
    }
    SECTION("lengths exceeding INT32_MAX cannot be serialized to BSON")
    {
        huge_binary_json j;
        j["b"] = huge_binary_json::binary(huge_binary_t{});
        CHECK_THROWS_WITH_AS(huge_binary_json::to_bson(j), "[json.exception.out_of_range.412] BSON length 2147483661 exceeds maximum of 2147483647", huge_binary_json::out_of_range&);
    }
    SECTION("string length must be at least 1")
    {
        // from https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=11175
@@ -529,41 +498,6 @@ TEST_CASE("BSON")
            CHECK(json::from_bson(result, true, false) == j);
        }
        SECTION("non-empty object with binary member without subtype")
        {
            const size_t N = 10;
            const auto s = std::vector<std::uint8_t>(N, 'x');
            json const j =
            {
                { "entry", json::binary(s) }
            };
            CHECK(!j.at("entry").get_binary().has_subtype());
            std::vector<std::uint8_t> const expected =
            {
                0x1B, 0x00, 0x00, 0x00, // size (little endian)
                0x05, // entry: binary
                'e', 'n', 't', 'r', 'y', '\x00',
                0x0A, 0x00, 0x00, 0x00, // size of binary (little endian)
                0x00, // Generic binary subtype
                0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
                0x00 // end marker
            };
            const auto result = json::to_bson(j);
            CHECK(result == expected);
            // roundtrip adds the generic binary subtype
            const auto roundtrip = json::from_bson(result);
            CHECK(roundtrip != j);
            CHECK(roundtrip.at("entry").get_binary().has_subtype());
            CHECK(roundtrip.at("entry").get_binary().subtype() == 0);
            CHECK(json::from_bson(result, true, false) == roundtrip);
        }
        SECTION("non-empty object with binary member with subtype")
        {
            // an MD5 hash
@@ -860,41 +794,6 @@ TEST_CASE("Incomplete BSON Input")
        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
    }
    SECTION("Incomplete BSON Input 5")
    {
        std::vector<std::uint8_t> const incomplete_bson =
        {
            0x09, 0x00, 0x00, 0x00, // size (little endian)
            0x08,                   // entry: boolean
            'b', '\x00'             // key, unexpected EOF before the value
        };
        json _;
        CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), "[json.exception.parse_error.110] parse error at byte 8: syntax error while parsing BSON number: unexpected end of input", json::parse_error&);
        CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
        SaxCountdown scp(0);
        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
    }
    SECTION("Incomplete BSON Input 6")
    {
        std::vector<std::uint8_t> const incomplete_bson =
        {
            0x0F, 0x00, 0x00, 0x00, // size (little endian)
            0x05,                   // entry: binary
            'b', '\x00',            // key
            0x00, 0x00, 0x00, 0x00  // length, unexpected EOF before the subtype
        };
        json _;
        CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), "[json.exception.parse_error.110] parse error at byte 12: syntax error while parsing BSON number: unexpected end of input", json::parse_error&);
        CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
        SaxCountdown scp(0);
        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
    }
    SECTION("Improve coverage")
    {
        SECTION("key")
@@ -955,62 +854,6 @@ TEST_CASE("Unsupported BSON input")
    CHECK(!json::sax_parse(bson, &scp, json::input_format_t::bson));
 }
 TEST_CASE("BSON document size mismatch")
 {
    json _;
    SECTION("top-level document declaring more bytes than it contains")
    {
        // empty object, but the length prefix claims 6 bytes instead of 5
        std::vector<std::uint8_t> const input = {0x06, 0x00, 0x00, 0x00, 0x00};
        CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[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::parse_error&);
        CHECK(json::from_bson(input, true, false).is_discarded());
    }
    SECTION("top-level document with a negative size")
    {
        std::vector<std::uint8_t> const input = {0xFF, 0xFF, 0xFF, 0xFF, 0x00};
        CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size -1 does not match the number of bytes read (5)", json::parse_error&);
        CHECK(json::from_bson(input, true, false).is_discarded());
    }
    SECTION("embedded document whose size disagrees with its terminator")
    {
        // the embedded document "d" declares 0x7FFFFFFF bytes but its 0x00
        // terminator falls right after {"a":null}; the length prefix would
        // otherwise let the following "h" element be read as a member of the
        // enclosing document instead of "d"
        std::vector<std::uint8_t> const input =
        {
            0x00, 0x00, 0x00, 0x00, // outer size
            0x03, 'd', 0x00,        // entry: embedded document "d"
            0xFF, 0xFF, 0xFF, 0x7F, //   embedded size 0x7FFFFFFF
            0x0A, 'a', 0x00,        //   entry: null "a"
            0x00,                   //   embedded end marker
            0x08, 'h', 0x00, 0x01,  // entry: bool "h" = true
            0x00                    // outer end marker
        };
        CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON document: document size 2147483647 does not match the number of bytes read (8)", json::parse_error&);
        CHECK(json::from_bson(input, true, false).is_discarded());
    }
    SECTION("embedded array whose size disagrees with its terminator")
    {
        // array [42] is 12 bytes, but the length prefix claims 13
        std::vector<std::uint8_t> const input =
        {
            0x00, 0x00, 0x00, 0x00, // outer size
            0x04, 'a', 0x00,        // entry: array "a"
            0x0D, 0x00, 0x00, 0x00, //   array size 13 (real is 12)
            0x10, '0', 0x00, 0x2A, 0x00, 0x00, 0x00, //   entry: int32 "0" = 42
            0x00,                   //   array end marker
            0x00                    // outer end marker
        };
        CHECK_THROWS_WITH_AS(_ = json::from_bson(input), "[json.exception.parse_error.112] parse error at byte 19: syntax error while parsing BSON document: document size 13 does not match the number of bytes read (12)", json::parse_error&);
        CHECK(json::from_bson(input, true, false).is_discarded());
    }
 }
 TEST_CASE("BSON numerical data")
 {
    SECTION("number")
@@ -1999,42 +1999,6 @@ TEST_CASE("CBOR regressions")
 }
 #endif
 TEST_CASE("CBOR definite length equal to the indefinite-length sentinel")
 {
    // A definite-length array or map whose declared element count equals the
    // reserved unknown_size() sentinel (SIZE_MAX) must be rejected. Otherwise
    // it is read as an indefinite-length container and the following bytes are
    // silently accepted instead of the (impossible) count being reported.
    json _;
    SECTION("array")
    {
        // 0x9B: array with eight-byte length; length = 0xFFFFFFFFFFFFFFFF
        const std::vector<uint8_t> input = {0x9B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x02, 0xFF};
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive array size", json::out_of_range&);
    }
    SECTION("map")
    {
        // 0xBB: map with eight-byte length; length = 0xFFFFFFFFFFFFFFFF
        const std::vector<uint8_t> input = {0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x61, 0x61, 0x01, 0xFF};
        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size", json::out_of_range&);
    }
    SECTION("indefinite-length containers are unaffected")
    {
        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01, 0x02, 0xFF})) == json({1, 2}));
        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 0x61, 0x01, 0xFF})) == json({{"a", 1}}));
    }
    SECTION("ordinary four-byte length containers are unaffected")
    {
        // 0x9A/0xBA carry a four-byte length; a normal count still parses
        CHECK(json::from_cbor(std::vector<uint8_t>({0x9A, 0x00, 0x00, 0x00, 0x02, 0x01, 0x02})) == json({1, 2}));
        CHECK(json::from_cbor(std::vector<uint8_t>({0xBA, 0x00, 0x00, 0x00, 0x01, 0x61, 0x61, 0x01})) == json({{"a", 1}}));
    }
 }
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {
    SECTION("input from flynn")
@@ -2345,7 +2309,7 @@ TEST_CASE("all CBOR first bytes")
 }
 #endif
-TEST_CASE("examples from RFC 8949 Appendix A")
+TEST_CASE("examples from RFC 7049 Appendix A")
 {
    SECTION("numbers")
    {
@@ -2565,16 +2529,11 @@ TEST_CASE("Tagged values")
    const json j = "s";
    auto v = json::to_cbor(j);
-    const json j_bin_payload = json::binary(std::vector<std::uint8_t> {0x01, 0x02, 0x03});
+    SECTION("0xC6..0xD4")
    auto v_bin_payload = json::to_cbor(j_bin_payload);
    SECTION("0xC0..0xD7")
    {
        for (const auto b : std::vector<std::uint8_t>
    {
-        0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5,
+        0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4
        0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
        0xD5, 0xD6, 0xD7
    })
        {
            CAPTURE(b);
@@ -2594,12 +2553,6 @@ TEST_CASE("Tagged values")
            auto j_tagged_stored = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::store);
            CHECK(j_tagged_stored == j);
            auto v_binary_tagged = v_bin_payload;
            v_binary_tagged.insert(v_binary_tagged.begin(), b);
            auto j_binary_tagged_stored = json::from_cbor(v_binary_tagged, true, true, json::cbor_tag_handler_t::store);
            CHECK(j_binary_tagged_stored == j_bin_payload);
            CHECK(!j_binary_tagged_stored.get_binary().has_subtype());
        }
    }
@@ -1440,13 +1440,6 @@ TEST_CASE("parser class")
            ]
        )";
        const auto* structured_object = R"(
            {
                "foo": [1, 2],
                "bar": 3
            }
        )";
        SECTION("filter nothing")
        {
            const json j_object = json::parse(s_object, [](int /*unused*/, json::parse_event_t /*unused*/, const json& /*unused*/) noexcept
@@ -1522,48 +1515,6 @@ TEST_CASE("parser class")
            CHECK (j_filtered2 == json({1}));
        }
        SECTION("filter array in object")
        {
            // the array is discarded once it is already stored under its key
            const json j_filtered1 = json::parse(structured_object, [](int /*unused*/, json::parse_event_t e, const json& /*parsed*/) noexcept
            {
                return e != json::parse_event_t::array_end;
            });
            CHECK (j_filtered1 == json({{"bar", 3}}));
            // the array is discarded before it is stored, leaving the
            // placeholder the key event wrote
            const json j_filtered2 = json::parse(structured_object, [](int /*unused*/, json::parse_event_t e, const json& /*parsed*/) noexcept
            {
                return e != json::parse_event_t::array_start;
            });
            CHECK (j_filtered2 == json({{"bar", 3}}));
        }
        SECTION("filter value in object")
        {
            // the value is discarded after its key was kept, leaving the
            // placeholder the key event wrote
            const json j_filtered1 = json::parse(structured_object, [](int /*unused*/, json::parse_event_t e, const json & parsed) noexcept
            {
                return !(e == json::parse_event_t::value && parsed == json(3));
            });
            CHECK (j_filtered1 == json({{"foo", {1, 2}}}));
            // the same value is discarded together with its key, so no
            // placeholder was stored for it
            const json j_filtered2 = json::parse(structured_object, [](int /*unused*/, json::parse_event_t e, const json & parsed) noexcept
            {
                return !((e == json::parse_event_t::key && parsed == json("bar")) ||
                         (e == json::parse_event_t::value && parsed == json(3)));
            });
            CHECK (j_filtered2 == json({{"foo", {1, 2}}}));
        }
        SECTION("filter specific events")
        {
            SECTION("first closing event")
@@ -15,8 +15,6 @@
 #include "doctest_compatibility.h"
 #include <cstdint>
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using nlohmann::json;
@@ -257,75 +255,6 @@ TEST_CASE("lexicographical comparison operators")
            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 21
        };
        SECTION("signed/unsigned mixed comparison above INT64_MAX")
        {
            const json above_int64_max = static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1ULL;
            const json max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
            const json negative_one = -1;
            const json one = 1;
            const json max_int64 = (std::numeric_limits<std::int64_t>::max)();
            CHECK_FALSE(above_int64_max == negative_one);
            CHECK(above_int64_max != negative_one);
            CHECK(negative_one < above_int64_max);
            CHECK(negative_one <= above_int64_max);
            CHECK_FALSE(negative_one > above_int64_max);
            CHECK_FALSE(negative_one >= above_int64_max);
            CHECK_FALSE(above_int64_max < negative_one);
            CHECK_FALSE(above_int64_max <= negative_one);
            CHECK(above_int64_max > negative_one);
            CHECK(above_int64_max >= negative_one);
            CHECK(negative_one != above_int64_max);
            CHECK_FALSE(negative_one == above_int64_max);
            CHECK_FALSE(max_uint64 == negative_one);
            CHECK(max_uint64 != negative_one);
            CHECK(negative_one < max_uint64);
            CHECK(negative_one <= max_uint64);
            CHECK_FALSE(negative_one > max_uint64);
            CHECK_FALSE(negative_one >= max_uint64);
            CHECK_FALSE(max_uint64 < negative_one);
            CHECK_FALSE(max_uint64 <= negative_one);
            CHECK(max_uint64 > negative_one);
            CHECK(max_uint64 >= negative_one);
            CHECK(negative_one != max_uint64);
            CHECK_FALSE(negative_one == max_uint64);
            CHECK_FALSE(one == above_int64_max);
            CHECK(one != above_int64_max);
            CHECK(one < above_int64_max);
            CHECK(one <= above_int64_max);
            CHECK_FALSE(one > above_int64_max);
            CHECK_FALSE(one >= above_int64_max);
            CHECK_FALSE(above_int64_max < one);
            CHECK_FALSE(above_int64_max <= one);
            CHECK(above_int64_max > one);
            CHECK(above_int64_max >= one);
            CHECK_FALSE(max_int64 == above_int64_max);
            CHECK(max_int64 != above_int64_max);
            CHECK(max_int64 < above_int64_max);
            CHECK(max_int64 <= above_int64_max);
            CHECK_FALSE(max_int64 > above_int64_max);
            CHECK_FALSE(max_int64 >= above_int64_max);
            CHECK_FALSE(above_int64_max < max_int64);
            CHECK_FALSE(above_int64_max <= max_int64);
            CHECK(above_int64_max > max_int64);
            CHECK(above_int64_max >= max_int64);
 #if JSON_HAS_THREE_WAY_COMPARISON
            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
            CHECK((negative_one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
            CHECK((above_int64_max <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
            CHECK((negative_one <=> max_uint64) == std::partial_ordering::less); // *NOPAD*
            CHECK((max_uint64 <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
            CHECK((one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
            CHECK((above_int64_max <=> one) == std::partial_ordering::greater); // *NOPAD*
            CHECK((max_int64 <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
            CHECK((above_int64_max <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
 #endif
        }
        SECTION("compares unordered")
        {
            std::vector<std::vector<bool>> expected =
@@ -427,30 +427,6 @@ TEST_CASE("deserialization")
                CHECK(l.events == std::vector<std::string>({"boolean(true)"}));
            }
            SECTION("from std::vector<signed char>")
            {
                std::vector<signed char> const v = {'t', 'r', 'u', 'e'};
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));
                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({"boolean(true)"}));
                // bytes outside ASCII are negative here and must not be sign-extended;
                // 0xC3 and 0xA9 do not fit in signed char (MSVC C4309), so spell them as negative values
                std::vector<signed char> const umlaut = {'"', static_cast<signed char>(0xC3 - 0x100), static_cast<signed char>(0xA9 - 0x100), '"'};
                CHECK(json::parse(umlaut) == json("\xC3\xA9"));
                CHECK(json::accept(umlaut));
                // 0xFF (spelled as -1 to stay in range) must not be reported as end of input
                std::vector<signed char> const trailing = {'t', 'r', 'u', 'e', static_cast<signed char>(0xFF - 0x100)};
                json _;
                CHECK_THROWS_WITH_AS(_ = json::parse(trailing), "[json.exception.parse_error.101] parse error at line 1, column 5: syntax error while parsing value - invalid literal; last read: 'true\xFF'; expected end of input", json::parse_error&);
                CHECK(!json::accept(trailing));
            }
            SECTION("from std::array")
            {
                std::array<uint8_t, 5> const v { {'t', 'r', 'u', 'e'} };
@@ -38,102 +38,6 @@ TEST_CASE("Better diagnostics with positions")
                             "[json.exception.type_error.302] type must be number, but is string", json::type_error);
    }
    SECTION("positions of strings containing escape sequences")
    {
        // escape sequences make the token longer than the string it parses to,
        // so the positions must not be derived from the parsed value's length
        const auto check = [](const std::string & text, const std::string & token)
        {
            CAPTURE(text)
            CAPTURE(token)
            const json j = json::parse(text);
            const json& v = j.at("a");
            CHECK(text.substr(v.start_pos(), v.end_pos() - v.start_pos()) == token);
        };
        check(R"({"a":"plain"})", R"("plain")");
        check(R"({"a":"tab\there"})", R"("tab\there")");
        check(R"({"a":"\n\n\n\n\n\n"})", R"("\n\n\n\n\n\n")");
        check(R"({"a":"\""})", R"("\"")");
        check(R"({"a":"\\"})", R"("\\")");
        check(R"({"a":"é"})", R"("é")");
        check(R"({"a":"🌞"})", R"("🌞")");
        check("{\"a\":\"\xc3\xa9\"}", "\"\xc3\xa9\"");  // multi-byte UTF-8, no escapes
        // a string at the root, where an escape would otherwise push the
        // reported start position past the opening quote
        const std::string root = R"("a\tb")";
        const json j = json::parse(root);
        CHECK(j.start_pos() == 0);
        CHECK(j.end_pos() == root.size());
    }
    SECTION("copying keeps the positions of nested values (#5387)")
    {
        // Values nested deeper than the copy constructor's descent bound are
        // copied without the call stack, on a path that has to carry the
        // positions over itself; shallower ones copy their containers, which
        // bring the positions along. Both sides of the bound are checked here.
        const auto check_copy = [](std::size_t depth, bool objects)
        {
            CAPTURE(depth)
            CAPTURE(objects)
            const std::string opening = objects ? R"({"a":)" : "[";
            const std::string closing = objects ? "}" : "]";
            std::string text;
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += opening;
            }
            text += "12";
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += closing;
            }
            const json original = json::parse(text);
            const json copy(original); // NOLINT(performance-unnecessary-copy-initialization)
            const json* o = &original;
            const json* c = &copy;
            for (std::size_t level = 0; level <= depth; ++level)
            {
                CAPTURE(level)
                REQUIRE(c->start_pos() == o->start_pos());
                REQUIRE(c->end_pos() == o->end_pos());
                if (level < depth)
                {
                    o = objects ? &o->at("a") : &o->at(0);
                    c = objects ? &c->at("a") : &c->at(0);
                }
            }
        };
        const auto check_arrays = [&check_copy](std::size_t depth)
        {
            check_copy(depth, false);
        };
        const auto check_objects = [&check_copy](std::size_t depth)
        {
            check_copy(depth, true);
        };
        check_arrays(1);
        check_arrays(127);
        check_arrays(128);
        check_arrays(129);
        check_arrays(300);
        check_objects(1);
        check_objects(127);
        check_objects(128);
        check_objects(129);
        check_objects(300);
    }
    SECTION("JSON patch add to primitive parent (#4292)")
    {
        // the JSON Patch "add" target /foo/bar/baz has a string parent
@@ -273,62 +273,5 @@ TEST_CASE("Regression tests for extended diagnostics")
        CHECK(j1["numbers"]["two"] == 2);
        CHECK(j1["string"] == "t");
    }
    SECTION("Regression test for issue #5387 - copying keeps the parents of nested values")
    {
        // A value nested deeper than the copy constructor's descent bound is
        // copied without the call stack. Every container that path creates has
        // to have the parents of its children set, or the JSON Pointer in the
        // diagnostic is cut short.
        const std::size_t depth = 300;
        SECTION("objects")
        {
            json j = "not a number";
            std::string pointer;
            for (std::size_t i = 0; i < depth; ++i)
            {
                j = json{{"a", j}};
                pointer += "/a";
            }
            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
            const json* inner = &copy;
            for (std::size_t i = 0; i < depth; ++i)
            {
                inner = &inner->at("a");
            }
            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
            int i = 0;
            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
            CHECK(i == 0);
        }
        SECTION("arrays")
        {
            json j = "not a number";
            std::string pointer;
            for (std::size_t i = 0; i < depth; ++i)
            {
                j = json::array({j});
                pointer += "/0";
            }
            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
            const json* inner = &copy;
            for (std::size_t i = 0; i < depth; ++i)
            {
                inner = &inner->at(0);
            }
            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
            int i = 0;
            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
            CHECK(i == 0);
        }
    }
 }
@@ -12,7 +12,6 @@
 using nlohmann::json;
 #include <algorithm>
 #include <string>
 TEST_CASE("tests on very large JSONs")
 {
@@ -28,201 +27,3 @@ TEST_CASE("tests on very large JSONs")
    }
 }
 namespace
 {
 // Descend a chain of single-element containers and return the value at its end,
 // reporting the number of levels traversed in @a depth.
 //
 // The values in the test case below are nested far deeper than the call stack
 // can follow, so they must not be inspected with operator== or dump(): both are
 // still recursive and would overflow the stack themselves.
 const json* innermost_value(const json& j, std::size_t& depth)
 {
    const json* current = &j;
    depth = 0;
    while ((current->is_array() || current->is_object()) && !current->empty())
    {
        current = current->is_array()
                  ? &current->front()
                  : &current->begin().value();
        ++depth;
    }
    return current;
 }
 } // namespace
 TEST_CASE("tests on deeply nested JSONs")
 {
    // deep enough to exhaust the call stack, but small enough to stay cheap:
    // parsing is iterative, so building the values below costs little
    const std::size_t depth = 100000;
    SECTION("issue #5387 - stack overflow in the copy constructor")
    {
        SECTION("array")
        {
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
            std::size_t copy_depth = 0;
            CHECK(*innermost_value(copy, copy_depth) == 0);
            CHECK(copy_depth == depth);
        }
        SECTION("object")
        {
            std::string s;
            s.reserve((6 * depth) + 1);
            for (std::size_t i = 0; i < depth; ++i)
            {
                s += "{\"a\":";
            }
            s += '1';
            s.append(depth, '}');
            const json j = json::parse(s);
            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
            std::size_t copy_depth = 0;
            CHECK(*innermost_value(copy, copy_depth) == 1);
            CHECK(copy_depth == depth);
        }
        SECTION("copy assignment")
        {
            // operator=(basic_json) takes its argument by value, so the deep
            // copy happens in the copy constructor
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            json target;
            target = j;
            std::size_t target_depth = 0;
            CHECK(*innermost_value(target, target_depth) == 0);
            CHECK(target_depth == depth);
        }
        SECTION("depths around the bound of the recursive descent")
        {
            // The copy constructor descends into a bounded number of levels and
            // completes whatever is below that without the call stack. Cover
            // every depth around that bound, so that the two ways of copying
            // are known to meet cleanly - wherever the bound is set.
            for (std::size_t d = 1; d <= 300; ++d)
            {
                CAPTURE(d);
                const json array = json::parse(std::string(d, '[') + '0' + std::string(d, ']'));
                const json array_copy(array); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
                std::size_t array_depth = 0;
                CHECK(*innermost_value(array_copy, array_depth) == 0);
                CHECK(array_depth == d);
                std::string object_text;
                for (std::size_t i = 0; i < d; ++i)
                {
                    object_text += "{\"a\":";
                }
                object_text += '1';
                object_text.append(d, '}');
                const json object = json::parse(object_text);
                const json object_copy(object); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
                std::size_t object_depth = 0;
                CHECK(*innermost_value(object_copy, object_depth) == 1);
                CHECK(object_depth == d);
            }
        }
        SECTION("a value that is deep in one place only")
        {
            json j = json::object();
            j["shallow"] = 1;
            j["deep"] = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            j["also_shallow"] = json::array({1, 2, 3});
            const json copy(j);
            CHECK(copy["shallow"] == 1);
            CHECK(copy["also_shallow"] == json::array({1, 2, 3}));
            std::size_t deep_depth = 0;
            CHECK(*innermost_value(copy["deep"], deep_depth) == 0);
            CHECK(deep_depth == depth);
        }
        SECTION("comparing")
        {
            // Comparing used to descend once per level, and an ordered
            // comparison used to compare every pair of elements twice, once in
            // each direction, which took exponentially long in the nesting
            // depth. Both are gone: these finish in milliseconds, where the
            // second used to take longer than anyone would wait even for a
            // value nested only a few dozen levels deep.
            const std::string text = std::string(depth, '[') + '0' + std::string(depth, ']');
            const json j = json::parse(text);
            const json same = json::parse(text);
            const json larger = json::parse(std::string(depth, '[') + '1' + std::string(depth, ']'));
            CHECK(j == same);
            CHECK_FALSE(j == larger);
            CHECK(j != larger);
            CHECK(j < larger);
            CHECK_FALSE(larger < j);
            CHECK(larger > j);
            CHECK(j <= same);
            CHECK(j >= same);
            // a value that ends earlier is the smaller one
            const json shorter = json::parse(std::string(depth - 1, '[') + '0' + std::string(depth - 1, ']'));
            CHECK_FALSE(j == shorter);
        }
        SECTION("comparing objects")
        {
            std::string text;
            text.reserve((6 * depth) + 1);
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += "{\"a\":";
            }
            text += '1';
            text.append(depth, '}');
            const json j = json::parse(text);
            const json same = json::parse(text);
            CHECK(j == same);
            CHECK_FALSE(j != same);
            CHECK(j <= same);
            CHECK(j >= same);
        }
        SECTION("the copy is independent of the original")
        {
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            json copy(j);
            // reach the innermost value without recursing and replace it
            json* current = &copy;
            while (current->is_array() && !current->empty())
            {
                current = &current->front();
            }
            *current = 42;
            std::size_t unused = 0;
            CHECK(*innermost_value(copy, unused) == 42);
            CHECK(*innermost_value(j, unused) == 0);
        }
    }
 }
@@ -81,37 +81,3 @@ TEST_CASE("regression test for issue #3732 - iteration_proxy_value<iter_impl<ord
    };
    static_cast<void>(fn);
 }
 TEST_CASE("copying an ordered_json with nested values")
 {
    // ordered_map is backed by a vector, so copying an object that has
    // structured values takes a different route than copying a std::map-backed
    // one; see https://github.com/nlohmann/json/issues/5387
    ordered_json oj;
    oj["z"] = 1;
    oj["a"]["y"] = 2;
    oj["a"]["b"]["x"] = 3;
    oj["m"] = {1, 2, {{"w", 4}}};
    const ordered_json copy(oj);
    SECTION("the copy is equal to the original")
    {
        CHECK(copy == oj);
        CHECK(copy.dump() == oj.dump());
    }
    SECTION("the key order is preserved at every level")
    {
        CHECK(copy.dump() == R"({"z":1,"a":{"y":2,"b":{"x":3}},"m":[1,2,{"w":4}]})");
    }
    SECTION("the copy is independent of the original")
    {
        ordered_json mutated(oj);
        mutated["a"]["b"]["x"] = 99;
        CHECK(oj["a"]["b"]["x"] == 3);
        CHECK(mutated["a"]["b"]["x"] == 99);
    }
 }
@@ -53,34 +53,4 @@ TEST_CASE("type traits")
            // NOLINTEND(hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
        }
    }
    SECTION("char_traits")
    {
        SECTION("to_int_type does not sign-extend")
        {
            using unsigned_traits = nlohmann::detail::char_traits<unsigned char>;
            using signed_traits = nlohmann::detail::char_traits<signed char>;
            CHECK(unsigned_traits::to_int_type(static_cast<unsigned char>(0x7F)) == 0x7F);
            CHECK(unsigned_traits::to_int_type(static_cast<unsigned char>(0x80)) == 0x80);
            CHECK(unsigned_traits::to_int_type(static_cast<unsigned char>(0xFF)) == 0xFF);
            CHECK(signed_traits::to_int_type(static_cast<signed char>(0x7F)) == 0x7F);
            // 0x80 and 0xFF do not fit in signed char (MSVC C4309), so spell them as negative values
            CHECK(signed_traits::to_int_type(static_cast<signed char>(0x80 - 0x100)) == 0x80);
            CHECK(signed_traits::to_int_type(static_cast<signed char>(0xFF - 0x100)) == 0xFF);
        }
        SECTION("no byte value collides with eof")
        {
            using unsigned_traits = nlohmann::detail::char_traits<unsigned char>;
            using signed_traits = nlohmann::detail::char_traits<signed char>;
            for (int i = 0; i < 256; ++i)
            {
                CHECK(unsigned_traits::to_int_type(static_cast<unsigned char>(i)) != unsigned_traits::eof());
                CHECK(signed_traits::to_int_type(static_cast<signed char>(i)) != signed_traits::eof());
            }
        }
    }
 }
@@ -819,8 +819,6 @@ TEST_CASE("UBJSON")
                    CHECK_THROWS_WITH_AS(_ = json::from_ubjson(vec2), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A", json::parse_error);
                    std::vector<uint8_t> const vec3 = {'H', 'i', 2, '1', '.'};
                    CHECK_THROWS_WITH_AS(_ = json::from_ubjson(vec3), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1.", json::parse_error);
                    std::vector<uint8_t> const vec_overflow = {'H', 'i', 5, '1', 'e', '4', '0', '0'};
                    CHECK_THROWS_WITH_AS(_ = json::from_ubjson(vec_overflow), "[json.exception.out_of_range.406] number overflow parsing '1e400'", json::out_of_range&);
                    std::vector<uint8_t> const vec4 = {'H', 2, '1', '0'};
                    CHECK_THROWS_WITH_AS(_ = json::from_ubjson(vec4), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON size: expected length type specification (U, i, I, l, L) after '#'; last byte: 0x02", json::parse_error);
                }
@@ -1713,44 +1711,6 @@ TEST_CASE("UBJSON")
            CHECK(json::to_ubjson(json::from_ubjson(s_L)) == s_i);
        }
        SECTION("no-op markers")
        {
            // A no-op ('N') is valid wherever a value may start; it is consumed
            // by get_ignore_noop() before the value is read. It is not valid
            // where a string length type specification is expected.
            SECTION("accepted where a value may start")
            {
                // at top level, also repeated
                CHECK(json::from_ubjson(std::vector<uint8_t>({'N', 'i', 1})) == json(1));
                CHECK(json::from_ubjson(std::vector<uint8_t>({'N', 'N', 'N', 'i', 1})) == json(1));
                // inside an array of unknown size, before and after an element
                CHECK(json::from_ubjson(std::vector<uint8_t>({'[', 'N', 'i', 1, ']'})) == json({1}));
                CHECK(json::from_ubjson(std::vector<uint8_t>({'[', 'i', 1, 'N', ']'})) == json({1}));
                // inside an object of unknown size: before a key, between key
                // and value, and before the closing '}'
                CHECK(json::from_ubjson(std::vector<uint8_t>({'{', 'N', 'U', 1, 'a', 'i', 1, '}'})) == json({{"a", 1}}));
                CHECK(json::from_ubjson(std::vector<uint8_t>({'{', 'U', 1, 'a', 'N', 'i', 1, '}'})) == json({{"a", 1}}));
                CHECK(json::from_ubjson(std::vector<uint8_t>({'{', 'U', 1, 'a', 'i', 1, 'N', '}'})) == json({{"a", 1}}));
            }
            SECTION("rejected where a length type specification is expected")
            {
                json _;
                // after the 'S' marker of a string value
                std::vector<uint8_t> const v_S = {'S', 'N', 'U', 1, 'a'};
                CHECK_THROWS_WITH_AS(_ = json::from_ubjson(v_S), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON string: expected length type specification (U, i, I, l, L); last byte: 0x4E", json::parse_error&);
                // as the key length of an object with a known size, where
                // no-ops are not permitted in the first place
                std::vector<uint8_t> const v_key = {'{', '#', 'i', 1, 'N', 'U', 1, 'a', 'i', 1};
                CHECK_THROWS_WITH_AS(_ = json::from_ubjson(v_key), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing UBJSON string: expected length type specification (U, i, I, l, L); last byte: 0x4E", json::parse_error&);
            }
        }
        SECTION("number")
        {
            SECTION("float")
@@ -125,16 +125,6 @@ TEST_CASE("wide strings")
            std::u32string const w = U"\"\x110000";
            json _;
            CHECK_THROWS_AS(_ = json::parse(w), json::parse_error&);
            // a code unit above U+10FFFF must not be narrowed onto the EOF
            // sentinel: 0xFFFFFFFF would otherwise end the document silently and
            // let everything following it pass the strict end-of-input check
            std::u32string const trailing{U'[', U'1', U']', static_cast<char32_t>(0xFFFFFFFF), U'x'};
            CHECK_THROWS_WITH_AS(_ = json::parse(trailing), "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid literal; last read: '1]\xFF'; expected end of input", json::parse_error&);
            CHECK(!json::accept(trailing));
            // the same unit inside a string is reported as an ill-formed byte
            CHECK_THROWS_WITH_AS(_ = json::parse(std::u32string{U'"', static_cast<char32_t>(0xFFFFFFFF), U'"'}), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\xFF'", json::parse_error&);
        }
    }
 }