Document zero-member support in the macro API reference

docs/mkdocs/docs/features/arbitrary_types.md already gained a note, but the three api/macros pages are where the parameter contract is actually specified and they still described member as a non-empty list. State that the list may be empty on each page, and add a note showing what the zero-member case generates: an empty JSON object for the plain macros, and base-type-only serialization for the derived ones. Both notes record that the WITH_NAMES variants do not support this. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Name the zero-member macro bodies by intent, not argument count
2026-08-28 20:07:32 +00:00 · 2026-08-20 09:01:11 +02:00 · 2026-08-19 23:05:45 +02:00 · 2026-08-19 21:03:08 +02:00 · 2026-07-12 06:37:49 +00:00 · 2026-07-11 23:55:43 +02:00
110 changed files with 1232 additions and 4182 deletions
@@ -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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+      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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+      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@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
+      uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
      with:
        languages: c-cpp

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

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
+      uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
@@ -19,7 +19,7 @@ jobs:
      pull-requests: write
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -17,7 +17,7 @@ jobs:

    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        with:
          sarif_file: results.sarif
@@ -32,12 +32,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -16,11 +16,11 @@ jobs:

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

-      - uses: actions/stale@4391f3da665fdf50b6810c1a66712fb9ba21aa93 # v11.0.0
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
        with:
          stale-issue-label: 'state: stale'
          stale-pr-label: 'state: stale'
@@ -21,11 +21,11 @@ jobs:
    runs-on: ubuntu-latest
    container: gcc:latest
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -35,7 +35,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
-        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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
@@ -104,11 +104,11 @@ jobs:
    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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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,
-          # 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
+          add-apt-repository -y ppa:ubuntu-toolchain-r/test
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic main"
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ bionic universe"
          apt-add-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial main"
@@ -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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        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@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
        with:
          egress-policy: audit

-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -24,7 +24,7 @@ jobs:
        architecture: [x64, x86]

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Set up MinGW
@@ -49,7 +49,7 @@ jobs:
    runs-on: windows-2022

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Set extra CXX_FLAGS for latest std_version
@@ -86,9 +86,9 @@ jobs:
    runs-on: windows-2025

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
      - name: Set extra CXX_FLAGS for latest std_version
        # /wd5285 silences C5285 emitted by the bundled third-party doctest.h, which
        # specializes std::tuple (newly diagnosed by the VS2026 v145 toolset)
@@ -122,7 +122,7 @@ jobs:
    runs-on: windows-11-arm

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
      - name: Run CMake (Release)
        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
        if: matrix.build_type == 'Release'
@@ -143,7 +143,7 @@ jobs:
        version: [11.0.1, 12.0.1, 13.0.1, 14.0.6, 15.0.7, 16.0.6, 18.1.8, 19.1.7, 20.1.8]

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Install Clang
@@ -153,16 +153,10 @@ jobs:
        with:
          platform: x64
          version: 12.2.0 # https://github.com/egor-tensin/setup-mingw/issues/14
-      # CMAKE_CXX_FLAGS_DEBUG is overridden to drop the default -g: linking
-      # test-regression2_cpp20 intermittently fails with "relocation truncated
-      # to fit: IMAGE_REL_AMD64_SECREL against `.debug_line'" because the
-      # MinGW linker cannot relocate the debug sections this test produces.
-      # The tests are only built and run here, so the debug info is not used.
      - name: Run CMake
        run: cmake -S . -B build ^
             -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^
             -DCMAKE_CXX_FLAGS="--target=x86_64-w64-mingw32 -stdlib=libstdc++ -pthread" ^
-             -DCMAKE_CXX_FLAGS_DEBUG="-g0" ^
             -DCMAKE_EXE_LINKER_FLAGS="-lwinpthread" ^
             -G"MinGW Makefiles" ^
             -DCMAKE_BUILD_TYPE=Debug ^
@@ -179,7 +173,7 @@ jobs:
        architecture: [Win32, x64]

    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      - name: Run CMake
@@ -192,14 +186,14 @@ jobs:
  ci_module_cpp20:
    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
        with:
          persist-credentials: false
      # The module test uses `import std;`, which needs CMake's experimental
      # import-std support. Its opt-in token is CMake-version-specific, so pin
      # CMake to the version whose token is set in tests/module_cpp20/CMakeLists.txt.
      - name: Get pinned CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
        with:
          cmakeVersion: 4.3.4
      - name: Run CMake (Debug)
@@ -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:
@@ -294,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
 )
@@ -49,7 +49,7 @@ Unlike the [`parse()`](parse.md) function, this function neither throws an excep
 :   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.

    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+    - `std::counted_iterator` with a different sentinel type

 ## Parameters

@@ -14,11 +14,7 @@ To store objects in C++, a type is defined by the template parameters explained
 ## Template parameters

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

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

 - Added in version 1.0.0.
- Made `capacity()` optional, so that array types such as `#!cpp std::deque` can be used, in version 3.13.0.
@@ -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:
-> Major type 2: A byte string. The number of bytes in the string is equal to the argument.
+[CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type as:
+> Major type 2: a byte string. The string's length in bytes is represented following the rules for positive integers
+> (major type 0).

 [MessagePack's documentation on the bin type
 family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family) describes this type as:
@@ -42,9 +43,7 @@ represent a byte array in modern C++.
    `value_type` must additionally be exactly one byte wide (e.g., `std::uint8_t`/`char`/`std::byte`): the binary
    serializers (CBOR, MessagePack, BSON, UBJSON) read and write the container's raw bytes via
    `reinterpret_cast`, which is only correct for byte-sized elements -- a container like
-    `#!cpp std::vector<std::intptr_t>` will not work as `BinaryType`. The elements must be stored contiguously, and
-    the binary readers additionally require `resize()` and `operator[]`. See
-    [Template Parameter Requirements](../../features/types/template_parameters.md#binarytype) for the full list.
+    `#!cpp std::vector<std::intptr_t>` will not work as `BinaryType`.

 ## Notes

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

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

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

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

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

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

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

 #### Default type
@@ -43,17 +43,6 @@ Strong guarantee: if an exception is thrown, there are no changes to any JSON va
 Throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if a string stored inside the JSON value
 is not UTF-8 encoded and `error_handler` is set to `strict`

-!!! warning "Serializing untrusted input"
-
-    When serializing values that may contain invalid or untrusted UTF-8 (e.g., bytes taken directly from network
-    input), `dump()` throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) in the default
-    `strict` mode. To serialize such data without throwing, pass
-    [`error_handler_t::replace`](error_handler_t.md) (substitutes U+FFFD) or
-    [`error_handler_t::ignore`](error_handler_t.md). Callers that serialize untrusted input on a crash-sensitive path
-    should either choose a non-strict error handler or wrap `dump()` in a `#!cpp try`/`#!cpp catch`.
-
-    See the [FAQ](../../home/faq.md#serializing-untrusted-or-invalid-utf-8) for details.
-
 ## Complexity

 Linear.
@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -39,10 +39,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

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

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

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

 #### Limitations

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

 ## Examples

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

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

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

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

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

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

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

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

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

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

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

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

 - Added in version 1.0.0.
- Allowed object types whose `erase(iterator)` returns `#!cpp void` in version 3.13.0.
@@ -48,7 +48,7 @@ static basic_json parse(IteratorType first, SentinelType last,
 :   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.

    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+    - `std::counted_iterator` with a different sentinel type

 ## Parameters

@@ -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
-  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.
+  read.
 - 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.
@@ -48,10 +48,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
    with a size of 1, 2, or 4 bytes (interpreted respectively as UTF-8, UTF-16, and UTF-32)

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for overload (2), for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for overload (2)

 `SAX`
 :   a class fulfilling the SAX event listener interface; see [`json_sax`](../json_sax/index.md)
@@ -23,11 +23,6 @@ JSON class into byte-sized characters during deserialization.
    `StringType`. To work with wide-character data, convert it to/from UTF-8 at the boundary instead -- see the
    FAQ's [wide string handling](../../home/faq.md#wide-string-handling) section for a conversion recipe.

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

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

 - Added in version 1.0.0.
- Removed the requirement that `string_t` be implicitly convertible from `#!cpp std::string`, which the BSON writer and
-  the UBJSON reader relied on, in version 3.13.0.
@@ -52,11 +52,6 @@ optional, `#!cpp bjdata_version_t::draft2` by default.

 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

-## Exceptions
-
- Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
-  is false.
-
 ## Complexity

 Linear in the size of the JSON value `j`.
@@ -40,15 +40,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  is not an object; example: `"to serialize to BSON, top-level type must be object, but is string"`
 - Throws [`out_of_range.409`](../../home/exceptions.md#jsonexceptionout_of_range409) if a key in the JSON object contains
  a null byte (code point U+0000); example: `"BSON key cannot contain code point U+0000 (at byte 2)"`
- Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
-  string, or binary value exceeds the range of the 32-bit BSON length field; example:
-  `"BSON length 2147483661 exceeds maximum of 2147483647"`

 ## Complexity

-Proportional to the size of the JSON value `j` multiplied by its maximum nesting
-depth, `O(n × d)`. BSON length prefixes are computed recursively before nested
-values are written.
+Linear in the size of the JSON value `j`.

 ## Examples

@@ -45,11 +45,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../

 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

-## Exceptions
-
- Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
-  is false.
-
 ## Complexity

 Linear in the size of the JSON value `j`.
@@ -37,14 +37,7 @@ Linear in the size of the JSON value.
 ## Notes

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

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

 - Added in version 2.0.0.
- Made the array/object decision independent of the object's iteration order in version 3.13.0.
@@ -38,8 +38,7 @@ When the macro is not defined, the library will define it to its default value.

    Diagnostic messages can also be controlled with the CMake option
    [`JSON_Diagnostics`](../../integration/cmake.md#json_diagnostics) (`OFF` by default)
-    which defines `JSON_DIAGNOSTICS` accordingly. Note this only applies when building the
-    library from source — see the pre-installed-package caveat on that page.
+    which defines `JSON_DIAGNOSTICS` accordingly.

 ## Examples

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

 1. This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/try_catch) calls inside the library.
-   The argument is the type of the exception to catch. The library uses it in a single place: to swallow any exception
-   escaping the parent-pointer check that [`JSON_DIAGNOSTICS`](json_diagnostics.md) adds to the class invariant. The
-   places where the library catches its own [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions
-   use `JSON_INTERNAL_CATCH` instead, which `JSON_CATCH_USER` also overrides unless `JSON_INTERNAL_CATCH_USER` is
-   defined. The macro is always followed by a scope.
+   The argument is the type of the exception to catch. As of version 3.8.0, the library only catches `std::out_of_range`
+   exceptions internally to rethrow them as [`json::out_of_range`](../../home/exceptions.md#out-of-range) exceptions.
+   The macro is always followed by a scope.
 2. This macro overrides `#!cpp throw` calls inside the library. The argument is the exception to be thrown. Note that
   `JSON_THROW_USER` should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield
   undefined behavior.
@@ -57,7 +57,8 @@ Summary:
 :   name of the base type (class, struct) `type` is derived from

 `member` (in)
-:   name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list
+:   name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated
+    list, which may also be empty

 ## Default definition

@@ -127,6 +128,20 @@ void to_json(BasicJsonType& j, const B& b) {
    - Macros 4, 5, and 6 have the same prerequisites of [NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE](nlohmann_define_type_non_intrusive.md).
    - Serialization/deserialization of base types must be defined.

+!!! info "Derived types without own members"
+
+    The member list may be empty. The macro then generates a `to_json`/`from_json` pair that only delegates to
+    the base type, so `type` serializes exactly like `base_type`:
+
+    ```cpp
+    struct derived : base
+    {
+        NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(derived, base)
+    };
+    ```
+
+    The `WITH_NAMES` variants do not support this.
+
 !!! warning "Implementation limits"

    See Implementation limits for [NLOHMANN_DEFINE_TYPE_INTRUSIVE](nlohmann_define_type_intrusive.md) and
@@ -33,7 +33,8 @@ Summary:
 :   name of the type (class, struct) to serialize/deserialize

 `member` (in)
-:   name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list
+:   name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated
+    list, which may also be empty

 ## Default definition

@@ -58,6 +59,20 @@ See the examples below for the concrete generated code.

 [GetNonDefNonCopy]: ../../features/arbitrary_types.md#how-can-i-use-get-for-non-default-constructiblenon-copyable-types

+!!! info "Types without members"
+
+    The member list may be empty. The macro then generates a `to_json` that produces an empty JSON object
+    `#!json {}`, and a `from_json` that reads no members:
+
+    ```cpp
+    struct marker
+    {
+        NLOHMANN_DEFINE_TYPE_INTRUSIVE(marker)
+    };
+    ```
+
+    The `WITH_NAMES` variants do not support this.
+
 !!! warning "Implementation limits"

    - The current implementation is limited to at most 63 member variables. If you want to serialize/deserialize types
@@ -33,7 +33,8 @@ Summary:
 :   name of the type (class, struct) to serialize/deserialize

 `member` (in)
-:   name of the (public) member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list
+:   name of the (public) member variable to serialize/deserialize; up to 63 members can be given as a
+    comma-separated list, which may also be empty

 ## Default definition

@@ -59,6 +60,18 @@ See the examples below for the concrete generated code.

 [GetNonDefNonCopy]: ../../features/arbitrary_types.md#how-can-i-use-get-for-non-default-constructiblenon-copyable-types

+!!! info "Types without members"
+
+    The member list may be empty. The macro then generates a `to_json` that produces an empty JSON object
+    `#!json {}`, and a `from_json` that reads no members:
+
+    ```cpp
+    struct marker {};
+    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(marker)
+    ```
+
+    The `WITH_NAMES` variants do not support this.
+
 !!! warning "Implementation limits"

    - The current implementation is limited to at most 63 member variables. If you want to serialize/deserialize types
@@ -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
-values from the same stream:
+`operator>>` parses exactly one JSON value and leaves the stream positioned right after it, so it can be called
+repeatedly to read a sequence of concatenated JSON values from the same stream:

 ```cpp
 json j1, j2;
-input >> j1;  // parses the first value
+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"
-
-    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.
+Note this does **not** work for [JSON Lines](../features/parsing/json_lines.md) (newline-delimited JSON) input --
+see that page for why and for the recommended alternative.

 !!! warning "Deprecation"

@@ -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
@@ -215,6 +215,24 @@ For _derived_ classes and structs, use the following macros
    nlohmann::ordered_json j = p; // keys appear in declaration order: name, address, age
    ```

+!!! note "Zero-member types"
+
+    All 12 `NLOHMANN_DEFINE_TYPE_*`/`NLOHMANN_DEFINE_DERIVED_TYPE_*` macros (excluding the `WITH_NAMES` variants)
+    also accept types with no member variables to serialize, producing/accepting an empty JSON object `{}`
+    (or, for the derived-type macros, just the base class's own JSON representation):
+
+    ```cpp
+    namespace ns {
+        struct marker {
+            bool operator==(const marker&) const { return true; }
+            NLOHMANN_DEFINE_TYPE_INTRUSIVE(marker)
+        };
+    }
+
+    ns::marker m{};
+    nlohmann::json j = m; // {}
+    ```
+
 !!! note "No macro for non-default-constructible types"

    There is currently no `NLOHMANN_DEFINE_TYPE_*`-style macro for types that are not
@@ -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
-    the 1-dimensional vector stored in `"_ArraySize_"` contains a single integer or two integers with one being 1, a
-    regular 1-D optimized array is generated instead.
-
-    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).
+    [`to_bjdata`](../../api/basic_json/to_bjdata.md), it is automatically converted into a compact BJData ND-array. The
+    only exception is, that when the 1-dimensional vector stored in `"_ArraySize_"` contains a single integer or two
+    integers with one being 1, a regular 1-D optimized array is generated.

    The current version of this library does not yet support automatic detection of and conversion from a nested JSON
    array input to a BJData ND-array.
@@ -35,19 +35,6 @@ The library uses the following mapping from JSON values types to BSON types:
    The mapping is **incomplete**, since only JSON-objects (and things contained therein) can be serialized to BSON.
    Also, keys may not contain U+0000, since they are serialized a zero-terminated c-strings.

-!!! warning "BSON type 0x11 interoperability"
-
-    The BSON specification defines type `0x11` as a Timestamp. This library uses marker `0x11` when serializing
-    `number_unsigned` values in the range `9223372036854775808..18446744073709551615`. Other BSON implementations may
-    therefore interpret these values as Timestamps instead of unsigned integers.
-
-!!! info "Binary values without a subtype"
-
-    BSON requires every binary value to have a subtype. If a binary value has no subtype, this library serializes it
-    with the generic subtype `0x00`. After deserialization, `has_subtype()` returns `true` and `subtype()` returns `0`.
-    As a result, serializing and deserializing a JSON object containing such a value produces a different JSON object,
-    even though the binary data is unchanged.
-
 ??? example

    ```cpp
@@ -95,19 +82,8 @@ The library maps BSON record types to JSON value types as follows:

 !!! note "Handling of BSON type 0x11"

-    This library deserializes BSON type `0x11` (Timestamp) as a `number_unsigned` value. The 64-bit value is preserved,
-    but the Timestamp type information is not.
-
-!!! warning "Lenient BSON input handling"
-
-    The BSON reader is lenient in a few areas where the BSON specification is more restrictive:
-
-    - array element keys are not checked against the required decimal sequence (`0`, `1`, `2`, ...),
-    - any non-zero byte is accepted as `true` for the boolean type, and
-    - the payload for binary subtype `0x02` is returned as-is, including its inner length prefix.
-
-    If BSON input must be validated for strict specification compliance, validate it separately before passing it to
-    `from_bson()`.
+    BSON type 0x11 is used to represent uint64 numbers. This library treats these values purely as uint64 numbers 
+    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

@@ -47,58 +47,6 @@ json j = {{"one", 1}, {"two", 2}};
 auto m = j.get<std::map<std::string, int>>();  // {{"one", 1}, {"two", 2}}
 ```

-`#!cpp std::pair` and `#!cpp std::tuple` are also supported, converting positionally to and from a JSON array:
-
-```cpp
-json j = {1.0, "hello", 42};
-auto t = j.get<std::tuple<double, std::string, int>>();  // {1.0, "hello", 42}
-```
-
-!!! warning "Serializing a `std::pair`/`std::tuple` whose every element is a string-keyed pair"
-
-    When *every* element of a `#!cpp std::pair` or `#!cpp std::tuple` is itself a two-element array whose first
-    element is a string (for example `#!cpp std::pair<std::string, int>`), serializing it produces a JSON **object**
-    instead of the expected array:
-
-    ```cpp
-    using kv = std::pair<std::string, int>;
-    json j = std::pair<kv, kv>{{"a", 1}, {"b", 2}};  // {"a":1,"b":2}, not [["a",1],["b",2]]
-    ```
-
-    This is a consequence of the [brace-initializer object-detection rule](creating_values.md): the same rule that
-    lets `#!cpp json{{"a", 1}, {"b", 2}}` create an object also fires here. The resulting object cannot be read back
-    into the original type (`#!cpp get<std::pair<kv, kv>>()` throws [`type_error.302`](../home/exceptions.md#jsonexceptiontype_error302)),
-    and duplicate keys collapse into one, losing elements. This only affects `#!cpp std::pair`/`#!cpp std::tuple`
-    themselves; a `#!cpp std::vector<std::pair<std::string, int>>`, or a pair/tuple with at least one element that is
-    not a string-keyed pair, serializes to an array as expected. To force an array, build one explicitly from the
-    elements with [`array`](../api/basic_json/array.md):
-
-    ```cpp
-    std::pair<kv, kv> p{{"a", 1}, {"b", 2}};
-    json a = json::array({p.first, p.second});  // [["a",1],["b",2]]
-    ```
-
-!!! info "Extracting references into a tuple"
-
-    A tuple type may also hold references (e.g. `#!cpp std::tuple<double&, std::string&>`) to avoid copying: `get`
-    then returns a tuple of references pointing directly at the elements stored inside the `basic_json` array,
-    rather than a tuple of copies:
-
-    ```cpp
-    json j = {1.0, "hello"};
-    auto refs = j.get<std::tuple<double&, std::string&>>();
-    std::get<1>(refs) = "world";  // modifies j[1] in place
-    ```
-
-    A referenced element must name the type the library actually *stores* — one of [`boolean_t`](../api/basic_json/boolean_t.md),
-    [`number_integer_t`](../api/basic_json/number_integer_t.md), [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md),
-    [`number_float_t`](../api/basic_json/number_float_t.md), [`string_t`](../api/basic_json/string_t.md),
-    [`binary_t`](../api/basic_json/binary_t.md), [`array_t`](../api/basic_json/array_t.md), or
-    [`object_t`](../api/basic_json/object_t.md). There is nothing else to refer to, so a reference to any other type is a
-    compile error even when a conversion would exist: `#!cpp std::tuple<int&>` is rejected, because the library stores a
-    `#!cpp number_integer_t` (`#!cpp std::int64_t` by default) and not an `#!cpp int`. This restriction applies only to
-    reference elements — a plain `#!cpp std::tuple<int>` converts by value as usual.
-
 ## Implicit conversions

 By default, a JSON value implicitly converts to a compatible C++ type, so the explicit `get` call can often be omitted:
@@ -146,34 +94,17 @@ which forces the explicit `get` form and can catch unintended conversions at com
    with a custom `adl_serializer<std::optional<T>>` specialization. Prefer `get<std::optional<T>>()`/`get_to()`
    over `static_cast` for optional types.

-!!! warning "Converting to a fixed-size destination does not check the array size"
+!!! warning "Converting to a fixed-size `std::array` does not check length"

-    Some destination types have a size that is fixed by their C++ type rather than by the JSON value:
-    `#!cpp std::pair<A, B>`, `#!cpp std::tuple<Ts...>`, `#!cpp std::array<T, N>`, C arrays `#!cpp T[N]`, and
-    `#!cpp std::map`/`#!cpp std::unordered_map` with a non-string key type (which is read from an array of
-    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.
+    Converting a JSON array to `#!cpp std::array<T, N>` does not check that the JSON array's size matches `N`:
+    if the JSON array is longer, the extra elements are silently dropped; if it is shorter, the remaining
+    `std::array` elements are left default-constructed. No exception is thrown in either case.

    ```cpp
    json j = {1, 2, 3, 4, 5};
-
-    auto a = j.get<std::array<int, 3>>();       // {1, 2, 3} -- elements 4 and 5 silently dropped
-    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
+    auto a = j.get<std::array<int, 3>>();  // {1, 2, 3} -- elements 4 and 5 silently dropped
    ```

-    If a size mismatch is an error in your application, check the size yourself before converting.
-
 ## Omitting a field when serializing `std::optional`

 By default, `to_json` for `std::optional<T>` writes either the value or `#!json null` -- there is no built-in way
@@ -205,20 +136,6 @@ std::vector<int> numbers = {1, 2, 3};
 json j = numbers;   // [1,2,3]
 ```

-!!! info "Constructing from a C++20 range view"
-
-    A `json` array can also be constructed directly from a C++20 range view (`std::ranges::view`), such as the result
-    of `std::views::filter` or `std::views::transform` -- no intermediate container is needed:
-
-    ```cpp
-    std::vector<int> nums{1, 2, 37, 42, 21};
-    auto filtered = nums | std::views::filter([](int i) { return i > 10; });
-    json j(filtered);   // [37,42,21]
-    ```
-
-    This requires [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) to be enabled and is unavailable on MinGW due
-    to incomplete C++20 ranges support there.
-
 ## Your own types

 The conversions above are built in for standard types. To make the same syntax work for **your own** types, provide
@@ -51,17 +51,7 @@ If you do want to preserve the **insertion order**, you can use the type [`nlohm
    --8<-- "examples/ordered_json.output"
    ```

-Alternatively, [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) also preserves the insertion order and, unlike [`ordered_map`](../api/ordered_map.md), keeps a lookup index, so it does not have the quadratic cost described below. It is used through a small adapter ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
-
-If the order does not matter and you only want faster lookup, `boost::unordered_flat_map`, `absl::flat_hash_map`, `absl::node_hash_map`, and several other hash maps work through an adapter that restores the template argument order `basic_json` expects; see [Template Parameter Requirements](types/template_parameters.md#objecttype). Note these are *unordered*, not insertion-ordered.
-
-[`tsl::ordered_map`](https://github.com/Tessil/ordered-map) cannot be used: its iterators expose the mapped value as `const`, while `basic_json` needs to modify it in place.
-
-The [`ordered_map`](../api/ordered_map.md) behind `nlohmann::ordered_json` is deliberately minimal and has no lookup
-index, so every key access is a linear scan and building an object of `n` keys costs O(n²). This is unnoticeable at
-typical object sizes but becomes significant for objects with many thousands of keys; see
-[`ordered_map` complexity](../api/ordered_map.md#complexity). The alternatives above keep a lookup index and do not
-have this cost.
+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)).

 ### Notes on parsing

@@ -28,22 +28,6 @@ Inputs consisting of multiple values separated by newlines are handled by the [J
 By default, the library rejects comments and trailing commas. Both can be enabled with parameters of the `parse`
 function — see [comments](../comments.md) and [trailing commas](../trailing_commas.md).

-## Strictness and trailing data
-
-[`parse`](../../api/basic_json/parse.md) reads a single JSON value and requires the whole input to be consumed: any
-non-whitespace data after the value is reported as a parse error. Use it when you want to guarantee that an input is
-exactly one complete JSON document.
-
-[`operator>>`](../../api/operator_gtgt.md) follows relaxed `#!cpp std::istream` semantics instead: it parses one JSON
-value and leaves the stream positioned right after it, without requiring the rest of the stream to be consumed. This is
-what makes it possible to read several concatenated values from the same stream, but it also means that "a valid
-document followed by trailing bytes" is accepted rather than rejected. If you are validating conformance, or need to
-reject any input that is not exactly one JSON document, prefer `parse`.
-
-When using `operator>>` to read several concatenated values this way, a value that is a number must be followed by
-whitespace, because `operator>>` consumes the character that terminates a number — see the
-[`operator>>` notes](../../api/operator_gtgt.md#notes) for details and examples.
-
 ## SAX vs. DOM parsing

 The library offers two parsing models:
@@ -49,5 +49,4 @@ JSON Lines input with more than one value is treated as invalid JSON by the [`pa
    with a JSON Lines input does not work, because the parser will try to parse one value after the last one.

    This is different from parsing a stream of *concatenated* (non-newline-delimited) JSON values, for which
-    `operator>>` does work, provided that a value that is a number is followed by whitespace -- see its
-    [notes](../../api/operator_gtgt.md#notes) for details.
+    `operator>>` does work -- see its [notes](../../api/operator_gtgt.md#notes) for details.
@@ -79,8 +79,7 @@ template<
    class NumberFloatType = double,
    template<typename U> class AllocatorType = std::allocator,
    template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer,
-    class BinaryType = std::vector<std::uint8_t>,
-    class CustomBaseClass = void
+    class BinaryType = std::vector<std::uint8_t>
 >
 class basic_json;
 ```
@@ -107,10 +106,6 @@ using number_float_t = NumberFloatType;
 using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
 ```

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

 ## Objects

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

 !!! 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 `#` for [UBJSON](../features/binary_formats/ubjson.md)/[BJData](../features/binary_formats/bjdata.md),
-or the encoded length for [CBOR](../features/binary_formats/cbor.md).
+The size (following `#`) of an UBJSON array or object exceeds the maximal capacity.

-!!! 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
@@ -965,19 +930,3 @@ A JSON Patch operation 'test' failed. The unsuccessful operation is also printed
    ```
    [json.exception.other_error.501] unsuccessful: {"op":"test","path":"/baz","value":"bar"}
    ```
-
-### json.exception.other_error.502
-
-[`to_ubjson`](../api/basic_json/to_ubjson.md) and [`to_bjdata`](../api/basic_json/to_bjdata.md) were called with
-`use_type = true` but `use_size = false`. UBJSON requires a size marker (`#`) after a type marker (`$`).
-
-!!! failure "Example message"
-
-    ```
-    [json.exception.other_error.502] use_type requires use_size = true
-    ```
-
-!!! note
-
-    This exception was added in version 3.13.0. Before that, debug builds aborted on an assertion and release builds
-    wrote a `$` marker without `#`, which [`from_ubjson`](../api/basic_json/from_ubjson.md) then rejected.
@@ -194,27 +194,6 @@ The library uses `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `d

 See [this section](../features/types/number_handling.md#number-serialization) on the library's number handling for more information.

-### Serializing untrusted or invalid UTF-8
-
-!!! question "Questions"
-
-    - Why does `dump()` throw when I serialize data that came from the network?
-    - Is CVE-2024-34363 a vulnerability in this library?
-
-Crashes reported against this library that stem from an uncaught
-[`type_error.316`](exceptions.md#jsonexceptiontype_error316) while serializing unvalidated input (e.g.,
-CVE-2024-34363) are a usage issue, not a library vulnerability:
-[`dump()`](../api/basic_json/dump.md) throws in its default `strict` mode because
-[RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259#section-8.1) requires JSON text to be valid UTF-8.
-
-The recommended pattern is to pass a non-strict [`error_handler`](../api/basic_json/error_handler_t.md) or to handle the
-exception:
-
-```cpp
-// replace invalid sequences with U+FFFD instead of throwing
-const auto s = j.dump(-1, ' ', false, json::error_handler_t::replace);
-```
-
 ### Using JSON values with `std::format` or `fmt`

 !!! question
@@ -14,5 +14,6 @@ You can sponsor this library at [GitHub Sponsors](https://github.com/sponsors/nl
 - [Steve Sperandeo](https://github.com/homer6)
 - [Robert Jefe Lindstädt](https://github.com/eljefedelrodeodeljefe)
 - [Steve Wagner](https://github.com/ciroque)
+- [Lion Yang](https://github.com/LionNatsu)

 Thanks everyone!
@@ -135,31 +135,6 @@ Enable CI build targets. The exact targets are used during the several CI steps

 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.

-!!! warning "Does not apply to a pre-installed package"
-
-    This option only takes effect when building nlohmann/json from source as part of your own
-    CMake project (e.g. via [`FetchContent`](#fetchcontent) or [`add_subdirectory`](#external)).
-    It has **no effect** on a package that was already built and installed elsewhere (Homebrew,
-    vcpkg, a system package, etc.) — the resulting compile definition is baked into the exported
-    `nlohmann_jsonTargets.cmake` at install time, and `set(JSON_Diagnostics ON)` before
-    `find_package()` does not change it (verified against the Homebrew-installed package: the
-    exported target still carries a fixed `$<$<BOOL:OFF>:JSON_DIAGNOSTICS=1>`, regardless of any
-    variable set in the consuming project).
-
-    To enable extended diagnostics for a pre-installed package, override the imported target's
-    property directly after `find_package()`:
-
-    ```cmake
-    find_package(nlohmann_json REQUIRED)
-    set_target_properties(nlohmann_json::nlohmann_json PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "JSON_DIAGNOSTICS=1")
-    ```
-
-    This only works cleanly when your project is the sole consumer of that imported target. If
-    nlohmann_json is pulled in from more than one place in your dependency graph with different
-    `JSON_DIAGNOSTICS` values, you may see a `"JSON_DIAGNOSTICS" redefined` compiler error, since
-    conflicting `-D` flags can end up on the same compile command line.
-
 ### `JSON_Diagnostic_Positions`

 Enable position diagnostics by defining macro [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md). This option is `OFF` by default.
@@ -930,12 +930,6 @@ If you are using [CocoaPods](https://cocoapods.org), you can use the library by
 to your podfile (see [an example](https://bitbucket.org/benman/nlohmann_json-cocoapod/src/master/)). Please file issues
 [here](https://bitbucket.org/benman/nlohmann_json-cocoapod/issues?status=new&status=open).

-## npm
-
-This project does not publish an official [npm](https://www.npmjs.com) package. The npm package
-[`nlohmann-json`](https://www.npmjs.com/package/nlohmann-json) (or similarly named packages) is not maintained or
-endorsed by this project. Use one of the package managers listed above, or integrate the single header directly.
-
 ## ESP-IDF and PlatformIO

 There is no official package published to the [ESP-IDF Component Registry](https://components.espressif.com) or the
@@ -98,7 +98,6 @@ nav:
      - Types:
          - features/types/index.md
          - features/types/number_handling.md
-          - features/types/template_parameters.md
  - Integration:
      - integration/index.md
      - integration/migration_guide.md
@@ -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"
@@ -101,10 +101,7 @@ class exception : public std::exception
                    {
                        if (&element.second == current)
                        {
-                            // data() is null-terminated, so a key containing
-                            // a null byte is cut short here rather than
-                            // truncating the whole message at what()
-                            tokens.emplace_back(element.first.data());
+                            tokens.emplace_back(element.first.c_str());
                            break;
                        }
                    }
@@ -114,9 +114,7 @@ std::size_t hash(const BasicJsonType& j)
            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
            for (const auto byte : j.get_binary())
            {
-                // the cast is needed for binary types whose value type is not
-                // an integer (e.g., std::byte)
-                seed = combine(seed, std::hash<std::uint8_t> {}(static_cast<std::uint8_t>(byte)));
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
            }
            return seed;
        }
@@ -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))
-        {
-            return false;
-        }
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);

        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)))
-        {
-            return false;
-        }
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
        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 get_number<std::uint8_t>(input_format_t::bson, value) && sax->boolean(value != 0);
+                return sax->boolean(get() != 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))
-        {
-            return false;
-        }
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);

        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_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), 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_container_size(len, size, "array") && get_cbor_array(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), 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_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), 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_container_size(len, size, "map") && get_cbor_object(size, tag_handler);
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
            }

            case 0xBF: // map (indefinite length)
                return get_cbor_object(detail::unknown_size(), tag_handler);

-            case 0xC0: // tagged item
-            case 0xC1:
-            case 0xC2:
-            case 0xC3:
-            case 0xC4:
-            case 0xC5:
-            case 0xC6:
+            case 0xC6: // tagged item
            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))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xD9:
                            {
                                std::uint16_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xDA:
                            {
                                std::uint32_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            case 0xDB:
                            {
                                std::uint64_t subtype_to_ignore{};
-                                if (!get_number(input_format_t::cbor, subtype_to_ignore))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype_to_ignore);
                                break;
                            }
                            default:
@@ -867,40 +795,28 @@ class binary_reader
                            case 0xD8:
                            {
                                std::uint8_t subtype{};
-                                if (!get_number(input_format_t::cbor, subtype))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype);
                                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))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype);
                                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))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype);
                                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))
-                                {
-                                    return false;
-                                }
+                                get_number(input_format_t::cbor, subtype);
                                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(mant <= 1023);
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    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
@@ -1955,29 +1846,6 @@ class binary_reader
        return get_ubjson_value(get_char ? get_ignore_noop() : current);
    }

-    /*!
-    @brief reject a negative UBJSON/BJData string length
-
-    String and key lengths are written with signed integer markers (i, I, l,
-    L). A negative value is malformed; without this check get_string() would
-    silently treat it as an empty string and leave the following bytes to be
-    misread as the next value. This mirrors the non-negative check the
-    optimized-container count path already performs in get_ubjson_size_value.
-
-    @param[in] len  the string length read from the input
-    @return whether the length is valid (non-negative)
-    */
-    template<typename NumberType>
-    bool check_ubjson_string_length(const NumberType len)
-    {
-        if (JSON_HEDLEY_UNLIKELY(len < 0))
-        {
-            return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
-                                    exception_message(input_format, "string length must not be negative", "string"), nullptr));
-        }
-        return true;
-    }
-
    /*!
    @brief reads a UBJSON string

@@ -1996,11 +1864,7 @@ class binary_reader
    {
        if (get_char)
        {
-            // no get_ignore_noop() here: the byte read next must be a string
-            // 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();
+            get();  // TODO(niels): may we ignore N here?
        }

        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
@@ -2019,25 +1883,25 @@ class binary_reader
            case 'i':
            {
                std::int8_t len{};
-                return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result);
+                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'I':
            {
                std::int16_t len{};
-                return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result);
+                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'l':
            {
                std::int32_t len{};
-                return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result);
+                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'L':
            {
                std::int64_t len{};
-                return get_number(input_format, len) && check_ubjson_string_length(len) && get_string(input_format, len, result);
+                return get_number(input_format, len) && get_string(input_format, len, result);
            }

            case 'u':
@@ -2559,7 +2423,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 +2436,8 @@ class binary_reader
                {
                    const int exp = (half >> 10u) & 0x1Fu;
                    const unsigned int mant = half & 0x3FFu;
-                    JSON_ASSERT(exp <= 31);
-                    JSON_ASSERT(mant <= 1023);
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
                    switch (exp)
                    {
                        case 0:
@@ -2890,20 +2754,7 @@ class binary_reader
            case token_type::value_unsigned:
                return sax->number_unsigned(number_lexer.get_number_unsigned());
            case token_type::value_float:
-            {
-                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));
-                }
-                // number_string is a std::string, while the SAX interface takes a
-                // string_t; convert explicitly, as the two are only implicitly
-                // convertible for some string types
-                return sax->number_float(parsed_float, string_t(number_string.data(), number_string.size()));
-            }
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
            case token_type::uninitialized:
            case token_type::literal_true:
            case token_type::literal_false:
@@ -220,29 +220,20 @@ class iterator_input_adapter
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
    // library iterators such as those of std::vector and std::string).
-    // Computing the available element count needs either same-type iterators
-    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
-    // e.g. std::counted_iterator paired with std::default_sentinel_t.
+    // The fast path also requires SentinelType == IteratorType so std::distance works.
    static constexpr bool iterator_is_contiguous =
+        std::is_same<IteratorType, SentinelType>::value && (
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
-        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
-#else
-        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
+            std::contiguous_iterator<IteratorType> ||
 #endif
+            std::is_pointer<IteratorType>::value);

    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        // std::ranges::distance also supports sized sentinels of a different
-        // type (e.g. std::counted_iterator + std::default_sentinel_t)
-        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
-#else
        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
-#endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -345,12 +336,8 @@ struct wide_string_input_helper<BaseInputAdapter, 4>
            }
            else
            {
-                // A code point above U+10FFFF has no UTF-8 encoding. Passing the
-                // unit through would narrow it to int, where 0xFFFFFFFF becomes
-                // 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;
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                utf8_bytes_filled = 1;
            }
        }
@@ -399,30 +386,17 @@ struct wide_string_input_helper<BaseInputAdapter, 2>
            }
            else
            {
-                // A supplementary code point is a high surrogate (0xD800..0xDBFF)
-                // followed by a low surrogate (0xDC00..0xDFFF). A lone low
-                // surrogate, a high surrogate at the end of the input, or a high
-                // surrogate followed by any other unit is malformed UTF-16. In
-                // that case the offending unit is passed through unchanged so the
-                // UTF-8 decoder rejects it, matching how \uXXXX surrogate escapes
-                // are handled in the lexer.
-                bool valid_pair = false;
-                if (wc <= 0xDBFF && JSON_HEDLEY_UNLIKELY(!input.empty()))
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
                {
                    const auto wc2 = static_cast<unsigned int>(input.get_character());
-                    if (0xDC00 <= wc2 && wc2 <= 0xDFFF)
-                    {
-                        const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
-                        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
-                        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
-                        utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
-                        utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
-                        utf8_bytes_filled = 4;
-                        valid_pair = true;
-                    }
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
                }
-
-                if (!valid_pair)
+                else
                {
                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
                    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
-                    // parses to, so the start position cannot be derived from
-                    // the value; use the offset the lexer recorded instead
-                    v.start_position = m_lexer_ref->get_token_start_position();
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
                    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();
-            }
-            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());
-            }
+            ref_stack.back()->m_data.m_value.array->pop_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
-                    // parses to, so the start position cannot be derived from
-                    // the value; use the offset the lexer recorded instead
-                    v.start_position = m_lexer_ref->get_token_start_position();
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
                    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 {};

@@ -88,13 +88,8 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci

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

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

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

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

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

    @complexity Linear in the number of reference tokens.

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

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

        return *result;
@@ -843,8 +823,7 @@ class json_pointer
        {
            // use the text between the beginning of the reference token
            // (start) and the last slash (slash).
-            const auto count = (slash == string_t::npos ? reference_string.size() : slash) - start;
-            auto reference_token = string_t(reference_string.data() + start, count);
+            auto reference_token = reference_string.substr(start, slash - start);

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

        BasicJsonType result;

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

        return result;
@@ -587,16 +587,59 @@ void templated_json_throw(ExceptionType exception)

 #define NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> __VA_ARGS__

+// Tags used to dispatch the NLOHMANN_DEFINE_TYPE_*/NLOHMANN_DEFINE_DERIVED_TYPE_*
+// macros below between a zero-member and a one-or-more-member implementation
+// (issue #4041, e.g. NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type) with no further
+// arguments). NLOHMANN_JSON_TYPE_TAG(...) expands to the token EMPTY when
+// __VA_ARGS__ is a single token (Type alone) and to MEMBERS for two or more
+// (Type, member...), naming the body the public macro dispatches to. It
+// reuses the existing 64-slot NLOHMANN_JSON_GET_MACRO dispatch with one extra
+// trailing sentinel token appended so its own trailing "..." is never left
+// completely empty at the lowest supported argument count --
+// invoking a variadic macro so that "..." matches nothing is only granted
+// unconditionally by the standard since C++20, and pre-C++20 compilers may
+// reject it under -pedantic regardless of what the macro body does.
+//
+// NLOHMANN_JSON_DERIVED_TYPE_TAG(...) answers the same question for the
+// derived-type macros, whose fixed prefix is Type,BaseType. It drops the
+// leading Type and defers to NLOHMANN_JSON_TYPE_TAG rather than shifting the
+// slot table by one: NLOHMANN_JSON_GET_MACRO only resolves 64 positional
+// arguments, so tagging Type,BaseType,member... directly would run out one
+// slot early and cap the derived-type macros at 62 members instead of the 63
+// that NLOHMANN_JSON_PASTE supports.
+#define NLOHMANN_JSON_CAT_(x, y) x ## y
+#define NLOHMANN_JSON_CAT(x, y) NLOHMANN_JSON_CAT_(x, y)
+
+#define NLOHMANN_JSON_TYPE_TAG(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, MEMBERS, \
+        MEMBERS, MEMBERS, MEMBERS, EMPTY, \
+        NLOHMANN_JSON_TYPE_TAG_SENTINEL))
+
+#define NLOHMANN_JSON_DERIVED_TYPE_TAG_(Type, ...) NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__)
+#define NLOHMANN_JSON_DERIVED_TYPE_TAG(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DERIVED_TYPE_TAG_(__VA_ARGS__))
+
 /*!
@brief macro
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
@since version 3.9.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -607,10 +650,15 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+// identical to NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -621,9 +669,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.3
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_EMPTY(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); })
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -633,10 +686,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.9.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -647,10 +707,15 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+// identical to NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -661,9 +726,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.3
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_EMPTY(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); })
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -673,10 +743,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -687,10 +764,15 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+// identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -701,9 +783,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_EMPTY(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -714,10 +801,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -728,10 +822,15 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+// identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -742,9 +841,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_EMPTY(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

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

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

 template<typename BasicJsonType>
@@ -232,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
-        // byte 0xFF indistinguishable from eof()
-        return static_cast<int_type>(static_cast<unsigned char>(c));
+        return static_cast<int_type>(c);
    }

    static char_type to_char_type(int_type i) noexcept
@@ -702,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
-// 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>
+template<typename Compare, typename A, typename B, typename = void>
 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;
@@ -779,13 +762,6 @@ using has_erase_with_key_type = typename std::conditional <
                                std::true_type,
                                std::false_type >::type;

-template<typename T>
-using detect_capacity = decltype(std::declval<const T&>().capacity());
-
-// type trait to check if a type has a capacity() member function
-template<typename T>
-struct has_capacity : std::integral_constant<bool, is_detected<detect_capacity, T>::value> {};
-
 // a naive helper to check if a type is an ordered_map (exploits the fact that
 // ordered_map inherits capacity() from std::vector)
 template <typename T>
@@ -261,7 +261,7 @@ class binary_writer

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

                // step 2: write the string
                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->data()),
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }
@@ -798,7 +798,7 @@ class binary_writer
                }
                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
                oa->write_characters(
-                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->data()),
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
                    j.m_data.m_value.string->size());
                break;
            }
@@ -813,10 +813,7 @@ class binary_writer
                bool prefix_required = true;
                if (use_type && !j.m_data.m_value.array->empty())
                {
-                    if (!use_count)
-                    {
-                        JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
-                    }
+                    JSON_ASSERT(use_count);
                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
@@ -862,10 +859,7 @@ class binary_writer

                if (use_type && (bjdata_draft3 || !j.m_data.m_value.binary->empty()))
                {
-                    if (!use_count)
-                    {
-                        JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
-                    }
+                    JSON_ASSERT(use_count);
                    oa->write_character(to_char_type('$'));
                    oa->write_character(bjdata_draft3 ? 'B' : 'U');
                }
@@ -887,9 +881,7 @@ class binary_writer
                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
                    {
                        oa->write_character(to_char_type(bjdata_draft3 ? 'B' : 'U'));
-                        // the cast is needed for binary types whose value type
-                        // is not an integer (e.g., std::byte)
-                        oa->write_character(to_char_type(static_cast<std::uint8_t>(j.m_data.m_value.binary->data()[i])));
+                        oa->write_character(to_char_type(j.m_data.m_value.binary->data()[i]));
                    }
                }

@@ -919,10 +911,7 @@ class binary_writer
                bool prefix_required = true;
                if (use_type && !j.m_data.m_value.object->empty())
                {
-                    if (!use_count)
-                    {
-                        JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
-                    }
+                    JSON_ASSERT(use_count);
                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
                    const bool same_prefix = std::all_of(j.begin(), j.end(),
                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
@@ -950,7 +939,7 @@ class binary_writer
                {
                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
                    oa->write_characters(
-                        reinterpret_cast<const CharType*>(el.first.data()),
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
                        el.first.size());
                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
                }
@@ -990,34 +979,16 @@ 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.data()),
-            name.size());
-        // the terminating null byte is written explicitly rather than taken
-        // from the buffer, so that string_t::data() need not be null-terminated
-        oa->write_character(to_char_type(0x00));
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
    }

    /*!
@@ -1056,11 +1027,10 @@ 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.data()),
-            value.size());
-        oa->write_character(to_char_type(0x00));
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
    }

    /*!
@@ -1100,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
    {
@@ -1113,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);
        }
    }

@@ -1151,8 +1121,7 @@ class binary_writer

        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
        {
-            const auto key = std::to_string(array_index++);
-            return result + calc_bson_element_size(string_t(key.data(), key.size()), el);
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
        });

        return sizeof(std::int32_t) + embedded_document_size + 1ul;
@@ -1173,17 +1142,13 @@ 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;

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

        oa->write_character(to_char_type(0x00));
@@ -1197,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());
@@ -1279,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);
@@ -1319,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)
        {
@@ -1682,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
-            // 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;
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
        }

        key = "_ArrayData_";
@@ -1715,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);
@@ -1746,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;
@@ -135,7 +135,7 @@ class serializer
                    auto i = val.m_data.m_value.object->cbegin();
                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
                    {
-                        o->write_characters(indent_string.data(), new_indent);
+                        o->write_characters(indent_string.c_str(), new_indent);
                        o->write_character('\"');
                        dump_escaped(i->first, ensure_ascii);
                        o->write_characters("\": ", 3);
@@ -146,14 +146,14 @@ class serializer
                    // last element
                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
-                    o->write_characters(indent_string.data(), new_indent);
+                    o->write_characters(indent_string.c_str(), new_indent);
                    o->write_character('\"');
                    dump_escaped(i->first, ensure_ascii);
                    o->write_characters("\": ", 3);
                    dump(i->second, true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');
-                    o->write_characters(indent_string.data(), current_indent);
+                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character('}');
                }
                else
@@ -208,18 +208,18 @@ class serializer
                    for (auto i = val.m_data.m_value.array->cbegin();
                            i != val.m_data.m_value.array->cend() - 1; ++i)
                    {
-                        o->write_characters(indent_string.data(), new_indent);
+                        o->write_characters(indent_string.c_str(), new_indent);
                        dump(*i, true, ensure_ascii, indent_step, new_indent);
                        o->write_characters(",\n", 2);
                    }

                    // last element
                    JSON_ASSERT(!val.m_data.m_value.array->empty());
-                    o->write_characters(indent_string.data(), new_indent);
+                    o->write_characters(indent_string.c_str(), new_indent);
                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');
-                    o->write_characters(indent_string.data(), current_indent);
+                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character(']');
                }
                else
@@ -265,7 +265,7 @@ class serializer
                        indent_string.resize(indent_string.size() * 2, ' ');
                    }

-                    o->write_characters(indent_string.data(), new_indent);
+                    o->write_characters(indent_string.c_str(), new_indent);

                    o->write_characters("\"bytes\": [", 10);

@@ -274,14 +274,14 @@ class serializer
                        for (auto i = val.m_data.m_value.binary->cbegin();
                                i != val.m_data.m_value.binary->cend() - 1; ++i)
                        {
-                            dump_integer(to_byte_value(*i));
+                            dump_integer(*i);
                            o->write_characters(", ", 2);
                        }
-                        dump_integer(to_byte_value(val.m_data.m_value.binary->back()));
+                        dump_integer(val.m_data.m_value.binary->back());
                    }

                    o->write_characters("],\n", 3);
-                    o->write_characters(indent_string.data(), new_indent);
+                    o->write_characters(indent_string.c_str(), new_indent);

                    o->write_characters("\"subtype\": ", 11);
                    if (val.m_data.m_value.binary->has_subtype())
@@ -293,7 +293,7 @@ class serializer
                        o->write_characters("null", 4);
                    }
                    o->write_character('\n');
-                    o->write_characters(indent_string.data(), current_indent);
+                    o->write_characters(indent_string.c_str(), current_indent);
                    o->write_character('}');
                }
                else
@@ -305,10 +305,10 @@ class serializer
                        for (auto i = val.m_data.m_value.binary->cbegin();
                                i != val.m_data.m_value.binary->cend() - 1; ++i)
                        {
-                            dump_integer(to_byte_value(*i));
+                            dump_integer(*i);
                            o->write_character(',');
                        }
-                        dump_integer(to_byte_value(val.m_data.m_value.binary->back()));
+                        dump_integer(val.m_data.m_value.binary->back());
                    }

                    o->write_characters("],\"subtype\":", 12);
@@ -596,7 +596,7 @@ class serializer
            {
                case error_handler_t::strict:
                {
-                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s[s.size() - 1] | 0))), nullptr));
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
                }

                case error_handler_t::ignore:
@@ -703,19 +703,6 @@ class serializer
        pos += 6;
    }

-    /*!
-    @brief convert a single element of a binary value to its byte value
-
-    The elements of a binary value are dumped as the numbers 0..255, regardless
-    of the value type of the configured BinaryType: that type may be signed
-    (`char`), unsigned (`std::uint8_t`), or not an integer at all
-    (`std::byte`), none of which @ref dump_integer can handle uniformly.
-    */
-    static std::uint8_t to_byte_value(binary_char_t x) noexcept
-    {
-        return static_cast<std::uint8_t>(x);
-    }
-
    // templates to avoid warnings about useless casts
    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
    bool is_negative_number(NumberType x)
@@ -741,7 +728,8 @@ class serializer
    template < typename NumberType, detail::enable_if_t <
                   std::is_integral<NumberType>::value ||
                   std::is_same<NumberType, number_unsigned_t>::value ||
-                   std::is_same<NumberType, number_integer_t>::value,
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
                   int > = 0 >
    void dump_integer(NumberType x)
    {
@@ -8,56 +8,50 @@

 #pragma once

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

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {

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

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

 }  // namespace detail
@@ -783,76 +783,21 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return it;
    }

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

-    reference set_parent(reference j)
-    {
-#if JSON_DIAGNOSTICS
        // ordered_json uses a vector internally, so pointers could have
        // been invalidated; see https://github.com/nlohmann/json/issues/2962
 #ifdef JSON_HEDLEY_MSVC_VERSION
@@ -871,6 +816,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        j.m_parent = this;
 #else
        static_cast<void>(j);
+        static_cast<void>(old_capacity);
 #endif
        return j;
    }
@@ -2063,17 +2009,22 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    reference at(size_type idx)
    {
        // at only works for arrays
-        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
        {
            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
        }
-
-        if (JSON_HEDLEY_UNLIKELY(idx >= m_data.m_value.array->size()))
-        {
-            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
-        }
-
-        return set_parent((*m_data.m_value.array)[idx]);
    }

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

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

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

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

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

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

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

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

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

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

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

    /// @brief inserts copies of element into array
@@ -3561,10 +3516,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            if (merge_objects && it.value().is_object())
            {
                auto it2 = m_data.m_value.object->find(it.key());
-                // Only recurse when the existing value is itself an object.
-                // Otherwise overwrite, matching the documented "all other values
-                // are overwritten as usual" behavior (see #5402).
-                if (it2 != m_data.m_value.object->end() && it2->second.is_object())
+                if (it2 != m_data.m_value.object->end())
                {
                    it2->second.update(it.value(), true);
 #if JSON_DIAGNOSTICS
@@ -3700,12 +3652,6 @@ 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
-    // 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)                       \
    const auto lhs_type = lhs.type();                                                                    \
    const auto rhs_type = rhs.type();                                                                    \
@@ -3764,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)                                                   \
-               ? (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)); \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op 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)                                                   \
-               ? (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); \
-    }                                                                                             \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
    else if(compares_unordered(lhs, rhs))\
    {\
        return (unordered_result);\
@@ -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());
-        }
-    }
-}
@@ -11,10 +11,8 @@

 #include <nlohmann/json.hpp>

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

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

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

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

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

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

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

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

    SECTION("patch")
@@ -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);
-            }
        }
    }

@@ -2807,19 +2721,6 @@ TEST_CASE("BJData")
                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(v), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing BJData string: expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x31", json::parse_error&);
            }

-            SECTION("negative length")
-            {
-                json _;
-
-                std::vector<uint8_t> const vi = {'S', 'i', 0xFF};
-                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vi), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData string: string length must not be negative", json::parse_error&);
-                CHECK(json::from_bjdata(vi, true, false).is_discarded());
-
-                std::vector<uint8_t> const vl = {'S', 'l', 0xFF, 0xFF, 0xFF, 0xFF};
-                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vl), "[json.exception.parse_error.113] parse error at byte 6: syntax error while parsing BJData string: string length must not be negative", json::parse_error&);
-                CHECK(json::from_bjdata(vl, true, false).is_discarded());
-            }
-
            SECTION("parse bjdata markers in ubjson")
            {
                // create a single-character string for all number types
@@ -3843,48 +3744,6 @@ TEST_CASE("all BJData first bytes")
 }
 #endif

-TEST_CASE("BJData use_type requires use_size")
-{
-    SECTION("non-empty object throws other_error.502")
-    {
-        const json j = {{"a", 1}, {"b", 2}};
-        CHECK_THROWS_WITH_AS(json::to_bjdata(j, false, true),
-                             "[json.exception.other_error.502] use_type requires use_size = true",
-                             json::other_error&);
-    }
-
-    SECTION("non-empty array throws other_error.502")
-    {
-        const json j = {1, 2, 3};
-        CHECK_THROWS_WITH_AS(json::to_bjdata(j, false, true),
-                             "[json.exception.other_error.502] use_type requires use_size = true",
-                             json::other_error&);
-    }
-
-    SECTION("scalars do not throw with use_type=true, use_count=false")
-    {
-        CHECK_NOTHROW(json::to_bjdata(42, false, true));
-        CHECK_NOTHROW(json::to_bjdata(3.14, false, true));
-        CHECK_NOTHROW(json::to_bjdata("hello", false, true));
-        CHECK_NOTHROW(json::to_bjdata(true, false, true));
-        CHECK_NOTHROW(json::to_bjdata(nullptr, false, true));
-    }
-
-    SECTION("empty containers do not throw with use_type=true, use_count=false")
-    {
-        CHECK_NOTHROW(json::to_bjdata(json::array(), false, true));
-        CHECK_NOTHROW(json::to_bjdata(json::object(), false, true));
-    }
-
-    SECTION("valid combinations on non-empty containers")
-    {
-        const json j = {{"a", 1}, {"b", 2}};
-        CHECK_NOTHROW(json::to_bjdata(j, false, false));
-        CHECK_NOTHROW(json::to_bjdata(j, true, false));
-        CHECK_NOTHROW(json::to_bjdata(j, true, true));
-    }
-}
-
 TEST_CASE("BJData roundtrips" * doctest::skip())
 {
    SECTION("input from self-generated BJData files")
@@ -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});
-    auto v_bin_payload = json::to_cbor(j_bin_payload);
-
-    SECTION("0xC0..0xD7")
+    SECTION("0xC6..0xD4")
    {
        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,
-        0xD5, 0xD6, 0xD7
+        0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4
    })
        {
            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 =
@@ -1782,21 +1782,6 @@ TEST_CASE("std::optional")
                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
-
-        // Assignment goes through the same overload resolution as direct
-        // construction, so it throws for the same reason. This relies on
-        // basic_json's implicit conversion operator, so it only applies
-        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
-#if JSON_USE_IMPLICIT_CONVERSIONS
-        std::optional<std::string> opt_assign;
-        CHECK_THROWS_WITH_AS(opt_assign = j_null,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-#endif
-
-        // get_to() is the correct way to obtain std::nullopt from a JSON null.
-        std::optional<std::string> opt_get_to = "placeholder";
-        j_null.get_to(opt_get_to);
-        CHECK(opt_get_to == std::nullopt);
    }

    SECTION("string")
@@ -1,136 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <deque>
-#include <map>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace
-{
-
-// std::deque has no capacity() member function, which the library only needs
-// to detect a reallocation for JSON_DIAGNOSTICS
-using deque_json = nlohmann::basic_json<std::map, std::deque>;
-
-// a std::vector whose at() is hidden: the library performs its own bounds
-// check and must not fall back to the container's checked accessor
-template<class T, class Allocator = std::allocator<T>>
-class vector_without_at : public std::vector<T, Allocator>
-{
-  public:
-    using std::vector<T, Allocator>::vector;
-
-    void at() = delete;
-};
-
-using no_at_json = nlohmann::basic_json<std::map, vector_without_at>;
-
-} // namespace
-
-TEST_CASE("array type without capacity()")
-{
-    SECTION("the iterators of the default configuration stay nothrow movable")
-    {
-        // basic_json's iterators take their exception specification from the
-        // container iterators; std::deque's is not nothrow move constructible
-        // with older standard libraries, which must not cost the default
-        // configuration its noexcept
-        CHECK(std::is_nothrow_move_constructible<nlohmann::json::iterator>::value);
-        CHECK(std::is_nothrow_move_assignable<nlohmann::json::iterator>::value);
-        CHECK(std::is_nothrow_move_constructible<nlohmann::json::const_iterator>::value);
-        CHECK(std::is_move_constructible<deque_json::iterator>::value);
-        CHECK(std::is_move_assignable<deque_json::iterator>::value);
-    }
-
-    SECTION("adding elements")
-    {
-        deque_json j = deque_json::array();
-        j.push_back(1);
-        j.push_back("two");
-        j.emplace_back(3);
-        j += 4;
-
-        CHECK(j.size() == 4);
-        CHECK(j == deque_json({1, "two", 3, 4}));
-        CHECK(j.back() == 4);
-        CHECK(j.front() == 1);
-    }
-
-    SECTION("accessing and modifying elements")
-    {
-        auto j = deque_json::parse(R"([1,2,3])");
-
-        CHECK(j[1] == 2);
-        CHECK(j.at(2) == 3);
-
-        // growing through operator[] fills up with null values
-        j[5] = 6;
-        CHECK(j.size() == 6);
-        CHECK(j[4].is_null());
-        CHECK(j[5] == 6);
-
-        j.erase(0);
-        CHECK(j == deque_json({2, 3, nullptr, nullptr, 6}));
-
-        auto it = j.erase(j.begin());
-        CHECK(*it == 3);
-
-        j.insert(j.begin(), 1);
-        CHECK(j.front() == 1);
-    }
-
-    SECTION("serialization and deserialization")
-    {
-        const auto j = deque_json::parse(R"({"a":[1,[2,3]],"b":[]})");
-        CHECK(j.dump() == R"({"a":[1,[2,3]],"b":[]})");
-        CHECK(deque_json::parse(j.dump()) == j);
-        CHECK(deque_json::from_cbor(deque_json::to_cbor(j)) == j);
-
-        // empty containers are flattened to null and cannot be restored
-        const auto nested = deque_json::parse(R"({"a":[1,[2,3]]})");
-        CHECK(nested.flatten().unflatten() == nested);
-    }
-
-    SECTION("references stay valid while the array grows")
-    {
-        deque_json j = deque_json::array();
-        j.push_back(1);
-        auto& first = j[0];
-        for (int i = 0; i < 100; ++i)
-        {
-            j.push_back(i);
-        }
-        CHECK(&first == &j[0]);
-        CHECK(first == 1);
-    }
-}
-
-TEST_CASE("array type without at()")
-{
-    // built in memory rather than parsed, so that the exception message does
-    // not gain a byte range with JSON_DIAGNOSTIC_POSITIONS
-    no_at_json j = {1, 2, 3};
-    const auto& jc = j;
-
-    CHECK(j.at(0) == 1);
-    CHECK(j.at(2) == 3);
-    CHECK(jc.at(2) == 3);
-
-    CHECK_THROWS_WITH_AS(j.at(3), "[json.exception.out_of_range.401] array index 3 is out of range", no_at_json::out_of_range);
-    CHECK_THROWS_WITH_AS(jc.at(3), "[json.exception.out_of_range.401] array index 3 is out of range", no_at_json::out_of_range);
-
-    CHECK(j.at(no_at_json::json_pointer("/1")) == 2);
-    CHECK_THROWS_AS(j.at(no_at_json::json_pointer("/3")), no_at_json::out_of_range);
-}
@@ -1,79 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#ifdef JSON_HAS_CPP_17
-    #include <cstddef>
-#endif
-
-namespace
-{
-
-// a BinaryType whose value type is signed: the elements must still be
-// processed as the numbers 0..255
-using char_binary_json = nlohmann::basic_json <
-                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, std::vector<char>, void >;
-
-#ifdef JSON_HAS_CPP_17
-    // a BinaryType whose value type is not an integer type at all
-    using byte_binary_json = nlohmann::basic_json <
-    std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-    double, std::allocator, nlohmann::adl_serializer, std::vector<std::byte>, void >;
-#endif
-
-} // namespace
-
-TEST_CASE("binary type whose value type is not std::uint8_t")
-{
-    SECTION("a signed value type does not dump negative numbers")
-    {
-        const std::vector<char> chars{'\0', '\x01', '\xFF'};
-        CHECK(char_binary_json::binary(chars).dump() == R"({"bytes":[0,1,255],"subtype":null})");
-        CHECK(char_binary_json::binary(chars, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
-        CHECK(char_binary_json::binary({}).dump() == R"({"bytes":[],"subtype":null})");
-    }
-
-    SECTION("the default binary type is unchanged")
-    {
-        CHECK(nlohmann::json::binary({0, 1, 255}, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
-    }
-
-#ifdef JSON_HAS_CPP_17
-    SECTION("dumping a value type that is not an integer")
-    {
-        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
-        CHECK(byte_binary_json::binary(bytes).dump() == R"({"bytes":[0,1,255],"subtype":null})");
-        CHECK(byte_binary_json::binary(bytes, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
-        CHECK(byte_binary_json::binary({}).dump() == R"({"bytes":[],"subtype":null})");
-    }
-
-    SECTION("hashing and the binary formats")
-    {
-        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
-        const auto j = byte_binary_json::binary(bytes);
-
-        CHECK(std::hash<byte_binary_json> {}(j) == std::hash<byte_binary_json> {}(j));
-        CHECK(byte_binary_json::from_cbor(byte_binary_json::to_cbor(j)) == j);
-        CHECK(byte_binary_json::from_msgpack(byte_binary_json::to_msgpack(j)) == j);
-
-        // UBJSON has no binary type, so binary values are written as an array
-        CHECK(byte_binary_json::from_ubjson(byte_binary_json::to_ubjson(j)) == byte_binary_json({0, 1, 255}));
-    }
-#endif
-}
@@ -1,187 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <cstdint>
-#include <map>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-namespace
-{
-
-// An ObjectType that does *not* define a key_compare member type, which is
-// what every hash map looks like to the library.
-//
-// A hash map is deliberately not used here: object_t is probed for
-// key_compare inside the definition of basic_json, that is, while basic_json
-// is still an incomplete type, and whether a hash map can be instantiated
-// with an incomplete mapped type depends on the standard library (libstdc++ 9
-// needs the size of the mapped type for its node type and rejects it). So the
-// object type is built from std::map, and the inherited key_compare member
-// type is shadowed by an entity that is not a type -- the library's probe
-// then finds no type, exactly as for a hash map.
-template<class Key, class T, class Compare, class Allocator>
-struct no_key_compare_map : std::map<Key, T, Compare, Allocator>
-{
-    using base_t = std::map<Key, T, Compare, Allocator>;
-    using base_t::base_t;
-
-    // shadows base_t::key_compare, which is a type; never defined or called
-    void key_compare();
-};
-
-using no_key_compare_json = nlohmann::basic_json<no_key_compare_map>;
-
-// An ObjectType whose erase(iterator) returns void rather than the following
-// iterator, as for instance Abseil's hash maps do
-template<class Key, class T, class Compare, class Allocator>
-struct void_erase_map : std::map<Key, T, Compare, Allocator>
-{
-    using base_t = std::map<Key, T, Compare, Allocator>;
-    using base_t::base_t;
-    using iterator = typename base_t::iterator;
-    using base_t::erase;
-
-    void erase(iterator pos)
-    {
-        base_t::erase(pos);
-    }
-};
-
-using void_erase_json = nlohmann::basic_json<void_erase_map>;
-
-} // namespace
-
-TEST_CASE("object type whose erase() returns void")
-{
-    SECTION("erasing every element through the returned iterator")
-    {
-        void_erase_json j;
-        for (int i = 0; i < 8; ++i)
-        {
-            j["k" + std::to_string(i)] = i;
-        }
-
-        std::size_t erased = 0;
-        for (auto it = j.begin(); it != j.end(); ++erased)
-        {
-            it = j.erase(it);
-        }
-        CHECK(erased == 8);
-        CHECK(j.empty());
-    }
-
-    SECTION("erasing in the middle returns the following element")
-    {
-        void_erase_json j;
-        for (int i = 0; i < 4; ++i)
-        {
-            j["k" + std::to_string(i)] = i;
-        }
-
-        auto it = j.begin();
-        ++it;
-        const auto after = j.erase(it);
-        CHECK(j.size() == 3);
-        CHECK(after.key() == "k2");
-        CHECK(after.value() == 2);
-        CHECK(!j.contains("k1"));
-    }
-
-    SECTION("the other erase overloads are unaffected")
-    {
-        void_erase_json j;
-        j["a"] = 1;
-        j["b"] = 2;
-        j["c"] = 3;
-
-        CHECK(j.erase("a") == 1);
-        CHECK(j.erase("nope") == 0);
-        j.erase(j.begin(), j.end());
-        CHECK(j.empty());
-    }
-}
-
-TEST_CASE("object type without key_compare")
-{
-    SECTION("object_comparator_t falls back to default_object_comparator_t")
-    {
-        CHECK(std::is_same < no_key_compare_json::object_comparator_t,
-              no_key_compare_json::default_object_comparator_t >::value);
-    }
-
-    SECTION("object types defining key_compare are unaffected")
-    {
-        CHECK(std::is_same<nlohmann::json::object_comparator_t,
-              nlohmann::json::object_t::key_compare>::value);
-        CHECK(std::is_same<nlohmann::ordered_json::object_comparator_t,
-              nlohmann::ordered_json::object_t::key_compare>::value);
-    }
-
-    SECTION("creating and accessing values")
-    {
-        no_key_compare_json j;
-        j["one"] = 1;
-        j["two"] = "zwei";
-        j["three"]["nested"] = true;
-
-        CHECK(j.size() == 3);
-        CHECK(j.at("one") == 1);
-        CHECK(j["two"] == "zwei");
-        CHECK(j["three"]["nested"] == true);
-        CHECK(j.contains("one"));
-        CHECK(!j.contains("four"));
-        CHECK(j.find("one") != j.end());
-        CHECK(j.count("one") == 1);
-        CHECK(j.erase("one") == 1);
-        CHECK(j.size() == 2);
-    }
-
-    SECTION("serialization and deserialization")
-    {
-        const auto j = no_key_compare_json::parse(R"({"a":[1,2,3],"b":{"c":null}})");
-        CHECK(j["a"].size() == 3);
-        CHECK(j["a"][2] == 3);
-        CHECK(j["b"]["c"].is_null());
-        CHECK(no_key_compare_json::parse(j.dump()) == j);
-    }
-
-    SECTION("binary formats")
-    {
-        const auto j = no_key_compare_json::parse(R"({"a":[1,2,3],"b":"x"})");
-        CHECK(no_key_compare_json::from_cbor(no_key_compare_json::to_cbor(j)) == j);
-        CHECK(no_key_compare_json::from_msgpack(no_key_compare_json::to_msgpack(j)) == j);
-    }
-
-    SECTION("flatten and unflatten")
-    {
-        // "o" has a key that looks like an array index, so unflatten() must
-        // not turn it into an array
-        const auto j = no_key_compare_json::parse(
-                           R"({"c":[1,2,3],"d":{"e":"s"},"n":[[0,1],[2]],"o":{"2":"x"}})");
-        CHECK(j.flatten().unflatten() == j);
-    }
-
-    SECTION("conversion to and from nlohmann::json")
-    {
-        const auto j = no_key_compare_json::parse(R"({"a":1,"b":[true,null]})");
-        const nlohmann::json converted(j);
-
-        CHECK(converted.is_object());
-        CHECK(converted["a"] == 1);
-        CHECK(converted["b"][0] == true);
-        CHECK(converted["b"][1].is_null());
-        CHECK(no_key_compare_json(converted) == j);
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	f8a0990582	Document zero-member support in the macro API reference docs/mkdocs/docs/features/arbitrary_types.md already gained a note, but the three api/macros pages are where the parameter contract is actually specified and they still described member as a non-empty list. State that the list may be empty on each page, and add a note showing what the zero-member case generates: an empty JSON object for the plain macros, and base-type-only serialization for the derived ones. Both notes record that the WITH_NAMES variants do not support this. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-20 09:01:11 +02:00
Niels Lohmann	7e87e5920f	Name the zero-member macro bodies by intent, not argument count The dispatch tag was the literal token 1 or N, pasted onto a macro prefix to select the zero-member or member-carrying body. For the derived-type macros that reads wrong: their tag is computed after dropping the leading Type, so the zero-member body was named _1 while taking two parameters (Type, BaseType). Emit EMPTY and MEMBERS instead. The mechanism is unchanged -- the tag is still a token pasted onto the prefix by NLOHMANN_JSON_CAT -- but the body names now say what they are rather than encoding an argument count that only lines up for half of the macros. Collapse the four duplicated zero-member bodies while here: with no members there is nothing to default, so each _WITH_DEFAULT_EMPTY body was a byte-for-byte copy of its plain counterpart. They are now one-line aliases, leaving a single definition of what an empty object serializes to per intrusive/non-intrusive and base/derived combination. No functional change: for both zero-member and member-carrying types the preprocessed to_json/from_json output is token-for-token identical, and the arity limits are unchanged (63 members, base and derived). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-19 23:05:45 +02:00
Niels Lohmann	0b28c63bad	Fix derived-type macro dispatch capping members at 62 instead of 63 NLOHMANN_JSON_GET_MACRO resolves 64 positional arguments, with NAME at position 65. NLOHMANN_JSON_TYPE_TAG dispatches on Type plus the member list, so it resolves correctly up to the 63 members NLOHMANN_JSON_PASTE supports. NLOHMANN_JSON_DERIVED_TYPE_TAG dispatched on the two-token Type,BaseType prefix plus the member list, running out one slot early: at 63 members, position 65 landed on the last member name instead of a sentinel and NLOHMANN_JSON_CAT built an undefined identifier such as NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_m63, with the compiler reporting "unknown type name 'm1'" once per member and nothing pointing at an argument-count limit. That silently reduced all six NLOHMANN_DEFINE_DERIVED_TYPE_* macros from 63 members to 62, contradicting the "up to 63 members" contract in docs/mkdocs/docs/api/macros/nlohmann_define_derived_type.md. Drop the leading Type and defer to NLOHMANN_JSON_TYPE_TAG so the tag is computed from BaseType plus the member list, which fits the available slots. The zero-own-member derived bodies are therefore selected by tag 1 rather than 2, and the sentinel table for the derived tag is no longer needed. Add a regression test at the documented maximum for both the plain and the derived macros; it fails to compile against the previous dispatch. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-08-19 21:03:08 +02:00
Niels LohmannandClaude	4dcd45b26d	Fix clang-tidy misc-const-correctness in unit-udt_macro.cpp The four zero-member ONLY_SERIALIZE test objects are only ever read (via to_json), never mutated, so mark them const per clang-tidy. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-12 06:37:49 +00:00
Niels Lohmann	9d83673263	Fix CI failures in zero-member NLOHMANN_DEFINE_TYPE_* macros Three issues surfaced on PR #5272's real CI that weren't caught by local testing against a narrower flag set: - GCC -Werror=noexcept: the four truly-empty from_json bodies (plain INTRUSIVE/NON_INTRUSIVE, with and without _WITH_DEFAULT) provably never throw but weren't declared noexcept; mark them noexcept explicitly. to_json and the derived-type from_json overloads are left alone since they genuinely can throw (object assignment / delegating to the base class's from_json). - clang-tidy bugprone-macro-parentheses: false positive on the same 8 zero-member bodies (Type/BaseType used purely as declarator types); suppressed with NOLINTNEXTLINE comments in the same style already used elsewhere in this file (see NLOHMANN_JSON_SERIALIZE_ENUM). - MSVC's traditional preprocessor doesn't fully expand NLOHMANN_JSON_CAT(prefix, NLOHMANN_JSON_TYPE_TAG(...))(...) in one pass, which broke a pre-existing one-member usage in unit-regression2.cpp with syntax errors. Wrap all 12 public dispatcher macros in an extra outer NLOHMANN_JSON_EXPAND(...), matching the pattern NLOHMANN_JSON_PASTE already uses for the same MSVC quirk. Re-verified against real GCC 16 and Clang at -std=c++11/14/17/20 with -pedantic -Werror -Wvariadic-macros -Wnoexcept, including the exact files that failed in CI (unit-udt_macro.cpp, unit-regression2.cpp), against both the modular headers and the re-amalgamated single header. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-11 23:55:43 +02:00
Niels Lohmann	d969eef216	Support zero-member types in NLOHMANN_DEFINE_TYPE_* macros (#4041 ) NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type) and its 11 sibling macros produced broken code for types with no members to serialize. Invoking a variadic macro so __VA_ARGS__ is empty is only standard-conforming since C++20, so a plain __VA_OPT__ fix (as tried in #5142) breaks every pre-C++20 build under -pedantic. Instead, make all 12 macros purely variadic and dispatch on argument count using a sentinel-padded extension of the existing NLOHMANN_JSON_GET_MACRO idiom, giving full C++11-C++26 support with no feature-test gate. Verified against real GCC 16 and Clang at -std=c++11/14/17/20 with -pedantic -Werror -Wvariadic-macros: zero regressions in the existing unit-udt_macro.cpp suite plus 12 new zero-member test cases. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-07-11 19:55:56 +02:00